From 9840a29082f9f53705574870b6403d9f967177dc Mon Sep 17 00:00:00 2001 From: "stainless-sdks[bot]" <167585319+stainless-sdks[bot]@users.noreply.github.com> Date: Wed, 16 Jul 2025 23:22:48 +0000 Subject: [PATCH 0001/1108] Initial commit --- README.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 00000000..a23d7055 --- /dev/null +++ b/README.md @@ -0,0 +1 @@ +# agentex-sdk-python \ No newline at end of file From ccfae0f878db382f15b0731178a8511cd1b60c1a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 16 Jul 2025 23:23:06 +0000 Subject: [PATCH 0002/1108] chore: configure new SDK language --- .devcontainer/Dockerfile | 9 + .devcontainer/devcontainer.json | 43 + .github/workflows/ci.yml | 96 + .gitignore | 16 + .python-version | 1 + .stats.yml | 4 + Brewfile | 2 + CONTRIBUTING.md | 128 ++ LICENSE | 201 ++ README.md | 380 +++- SECURITY.md | 23 + api.md | 152 ++ bin/publish-pypi | 6 + examples/.keep | 4 + mypy.ini | 50 + noxfile.py | 9 + pyproject.toml | 211 ++ requirements-dev.lock | 135 ++ requirements.lock | 72 + scripts/bootstrap | 19 + scripts/format | 8 + scripts/lint | 11 + scripts/mock | 41 + scripts/test | 61 + scripts/utils/ruffen-docs.py | 167 ++ scripts/utils/upload-artifact.sh | 27 + src/agentex_sdk/__init__.py | 100 + src/agentex_sdk/_base_client.py | 1992 +++++++++++++++++ src/agentex_sdk/_client.py | 544 +++++ src/agentex_sdk/_compat.py | 219 ++ src/agentex_sdk/_constants.py | 14 + src/agentex_sdk/_exceptions.py | 108 + src/agentex_sdk/_files.py | 123 + src/agentex_sdk/_models.py | 808 +++++++ src/agentex_sdk/_qs.py | 150 ++ src/agentex_sdk/_resource.py | 43 + src/agentex_sdk/_response.py | 832 +++++++ src/agentex_sdk/_streaming.py | 333 +++ src/agentex_sdk/_types.py | 219 ++ src/agentex_sdk/_utils/__init__.py | 57 + src/agentex_sdk/_utils/_logs.py | 25 + src/agentex_sdk/_utils/_proxy.py | 65 + src/agentex_sdk/_utils/_reflection.py | 42 + src/agentex_sdk/_utils/_resources_proxy.py | 24 + src/agentex_sdk/_utils/_streams.py | 12 + src/agentex_sdk/_utils/_sync.py | 86 + src/agentex_sdk/_utils/_transform.py | 447 ++++ src/agentex_sdk/_utils/_typing.py | 151 ++ src/agentex_sdk/_utils/_utils.py | 422 ++++ src/agentex_sdk/_version.py | 4 + src/agentex_sdk/lib/.keep | 4 + src/agentex_sdk/py.typed | 0 src/agentex_sdk/resources/__init__.py | 117 + src/agentex_sdk/resources/agents/__init__.py | 33 + src/agentex_sdk/resources/agents/agents.py | 487 ++++ src/agentex_sdk/resources/agents/name.py | 241 ++ src/agentex_sdk/resources/echo.py | 162 ++ src/agentex_sdk/resources/events.py | 294 +++ .../resources/messages/__init__.py | 33 + src/agentex_sdk/resources/messages/batch.py | 270 +++ .../resources/messages/messages.py | 491 ++++ src/agentex_sdk/resources/spans.py | 557 +++++ src/agentex_sdk/resources/states.py | 544 +++++ src/agentex_sdk/resources/tasks/__init__.py | 33 + src/agentex_sdk/resources/tasks/name.py | 324 +++ src/agentex_sdk/resources/tasks/tasks.py | 407 ++++ src/agentex_sdk/resources/tracker.py | 384 ++++ src/agentex_sdk/types/__init__.py | 45 + src/agentex_sdk/types/acp_type.py | 7 + src/agentex_sdk/types/agent.py | 29 + src/agentex_sdk/types/agent_list_params.py | 13 + src/agentex_sdk/types/agent_list_response.py | 10 + .../types/agent_register_params.py | 27 + src/agentex_sdk/types/agent_task_tracker.py | 34 + src/agentex_sdk/types/agents/__init__.py | 3 + src/agentex_sdk/types/data_content.py | 30 + src/agentex_sdk/types/data_content_param.py | 31 + src/agentex_sdk/types/echo_send_params.py | 11 + src/agentex_sdk/types/event.py | 38 + src/agentex_sdk/types/event_list_params.py | 22 + src/agentex_sdk/types/event_list_response.py | 10 + src/agentex_sdk/types/message_author.py | 7 + .../types/message_create_params.py | 25 + src/agentex_sdk/types/message_list_params.py | 14 + .../types/message_list_response.py | 10 + src/agentex_sdk/types/message_style.py | 7 + .../types/message_update_params.py | 25 + src/agentex_sdk/types/messages/__init__.py | 8 + .../types/messages/batch_create_params.py | 22 + .../types/messages/batch_create_response.py | 10 + .../types/messages/batch_update_params.py | 22 + .../types/messages/batch_update_response.py | 10 + src/agentex_sdk/types/span.py | 36 + src/agentex_sdk/types/span_create_params.py | 40 + src/agentex_sdk/types/span_list_params.py | 12 + src/agentex_sdk/types/span_list_response.py | 10 + src/agentex_sdk/types/span_update_params.py | 37 + src/agentex_sdk/types/state.py | 25 + src/agentex_sdk/types/state_create_params.py | 16 + src/agentex_sdk/types/state_list_params.py | 16 + src/agentex_sdk/types/state_list_response.py | 10 + src/agentex_sdk/types/state_update_params.py | 16 + src/agentex_sdk/types/streaming_status.py | 7 + src/agentex_sdk/types/task.py | 23 + src/agentex_sdk/types/task_list_response.py | 10 + src/agentex_sdk/types/task_message.py | 36 + src/agentex_sdk/types/tasks/__init__.py | 3 + src/agentex_sdk/types/text_content.py | 53 + src/agentex_sdk/types/text_content_param.py | 54 + src/agentex_sdk/types/tool_request_content.py | 36 + .../types/tool_request_content_param.py | 37 + .../types/tool_response_content.py | 36 + .../types/tool_response_content_param.py | 36 + src/agentex_sdk/types/tracker_list_params.py | 16 + .../types/tracker_list_response.py | 10 + .../types/tracker_update_params.py | 19 + tests/__init__.py | 1 + tests/api_resources/__init__.py | 1 + tests/api_resources/agents/__init__.py | 1 + tests/api_resources/agents/test_name.py | 192 ++ tests/api_resources/messages/__init__.py | 1 + tests/api_resources/messages/test_batch.py | 235 ++ tests/api_resources/tasks/__init__.py | 1 + tests/api_resources/tasks/test_name.py | 274 +++ tests/api_resources/test_agents.py | 374 ++++ tests/api_resources/test_client.py | 79 + tests/api_resources/test_echo.py | 91 + tests/api_resources/test_events.py | 204 ++ tests/api_resources/test_messages.py | 525 +++++ tests/api_resources/test_spans.py | 409 ++++ tests/api_resources/test_states.py | 454 ++++ tests/api_resources/test_tasks.py | 330 +++ tests/api_resources/test_tracker.py | 288 +++ tests/conftest.py | 84 + tests/sample_file.txt | 1 + tests/test_client.py | 1758 +++++++++++++++ tests/test_deepcopy.py | 58 + tests/test_extract_files.py | 64 + tests/test_files.py | 51 + tests/test_models.py | 936 ++++++++ tests/test_qs.py | 78 + tests/test_required_args.py | 111 + tests/test_response.py | 277 +++ tests/test_streaming.py | 250 +++ tests/test_transform.py | 453 ++++ tests/test_utils/test_proxy.py | 34 + tests/test_utils/test_typing.py | 73 + tests/utils.py | 159 ++ 148 files changed, 21987 insertions(+), 1 deletion(-) create mode 100644 .devcontainer/Dockerfile create mode 100644 .devcontainer/devcontainer.json create mode 100644 .github/workflows/ci.yml create mode 100644 .gitignore create mode 100644 .python-version create mode 100644 .stats.yml create mode 100644 Brewfile create mode 100644 CONTRIBUTING.md create mode 100644 LICENSE create mode 100644 SECURITY.md create mode 100644 api.md create mode 100644 bin/publish-pypi create mode 100644 examples/.keep create mode 100644 mypy.ini create mode 100644 noxfile.py create mode 100644 pyproject.toml create mode 100644 requirements-dev.lock create mode 100644 requirements.lock create mode 100755 scripts/bootstrap create mode 100755 scripts/format create mode 100755 scripts/lint create mode 100755 scripts/mock create mode 100755 scripts/test create mode 100644 scripts/utils/ruffen-docs.py create mode 100755 scripts/utils/upload-artifact.sh create mode 100644 src/agentex_sdk/__init__.py create mode 100644 src/agentex_sdk/_base_client.py create mode 100644 src/agentex_sdk/_client.py create mode 100644 src/agentex_sdk/_compat.py create mode 100644 src/agentex_sdk/_constants.py create mode 100644 src/agentex_sdk/_exceptions.py create mode 100644 src/agentex_sdk/_files.py create mode 100644 src/agentex_sdk/_models.py create mode 100644 src/agentex_sdk/_qs.py create mode 100644 src/agentex_sdk/_resource.py create mode 100644 src/agentex_sdk/_response.py create mode 100644 src/agentex_sdk/_streaming.py create mode 100644 src/agentex_sdk/_types.py create mode 100644 src/agentex_sdk/_utils/__init__.py create mode 100644 src/agentex_sdk/_utils/_logs.py create mode 100644 src/agentex_sdk/_utils/_proxy.py create mode 100644 src/agentex_sdk/_utils/_reflection.py create mode 100644 src/agentex_sdk/_utils/_resources_proxy.py create mode 100644 src/agentex_sdk/_utils/_streams.py create mode 100644 src/agentex_sdk/_utils/_sync.py create mode 100644 src/agentex_sdk/_utils/_transform.py create mode 100644 src/agentex_sdk/_utils/_typing.py create mode 100644 src/agentex_sdk/_utils/_utils.py create mode 100644 src/agentex_sdk/_version.py create mode 100644 src/agentex_sdk/lib/.keep create mode 100644 src/agentex_sdk/py.typed create mode 100644 src/agentex_sdk/resources/__init__.py create mode 100644 src/agentex_sdk/resources/agents/__init__.py create mode 100644 src/agentex_sdk/resources/agents/agents.py create mode 100644 src/agentex_sdk/resources/agents/name.py create mode 100644 src/agentex_sdk/resources/echo.py create mode 100644 src/agentex_sdk/resources/events.py create mode 100644 src/agentex_sdk/resources/messages/__init__.py create mode 100644 src/agentex_sdk/resources/messages/batch.py create mode 100644 src/agentex_sdk/resources/messages/messages.py create mode 100644 src/agentex_sdk/resources/spans.py create mode 100644 src/agentex_sdk/resources/states.py create mode 100644 src/agentex_sdk/resources/tasks/__init__.py create mode 100644 src/agentex_sdk/resources/tasks/name.py create mode 100644 src/agentex_sdk/resources/tasks/tasks.py create mode 100644 src/agentex_sdk/resources/tracker.py create mode 100644 src/agentex_sdk/types/__init__.py create mode 100644 src/agentex_sdk/types/acp_type.py create mode 100644 src/agentex_sdk/types/agent.py create mode 100644 src/agentex_sdk/types/agent_list_params.py create mode 100644 src/agentex_sdk/types/agent_list_response.py create mode 100644 src/agentex_sdk/types/agent_register_params.py create mode 100644 src/agentex_sdk/types/agent_task_tracker.py create mode 100644 src/agentex_sdk/types/agents/__init__.py create mode 100644 src/agentex_sdk/types/data_content.py create mode 100644 src/agentex_sdk/types/data_content_param.py create mode 100644 src/agentex_sdk/types/echo_send_params.py create mode 100644 src/agentex_sdk/types/event.py create mode 100644 src/agentex_sdk/types/event_list_params.py create mode 100644 src/agentex_sdk/types/event_list_response.py create mode 100644 src/agentex_sdk/types/message_author.py create mode 100644 src/agentex_sdk/types/message_create_params.py create mode 100644 src/agentex_sdk/types/message_list_params.py create mode 100644 src/agentex_sdk/types/message_list_response.py create mode 100644 src/agentex_sdk/types/message_style.py create mode 100644 src/agentex_sdk/types/message_update_params.py create mode 100644 src/agentex_sdk/types/messages/__init__.py create mode 100644 src/agentex_sdk/types/messages/batch_create_params.py create mode 100644 src/agentex_sdk/types/messages/batch_create_response.py create mode 100644 src/agentex_sdk/types/messages/batch_update_params.py create mode 100644 src/agentex_sdk/types/messages/batch_update_response.py create mode 100644 src/agentex_sdk/types/span.py create mode 100644 src/agentex_sdk/types/span_create_params.py create mode 100644 src/agentex_sdk/types/span_list_params.py create mode 100644 src/agentex_sdk/types/span_list_response.py create mode 100644 src/agentex_sdk/types/span_update_params.py create mode 100644 src/agentex_sdk/types/state.py create mode 100644 src/agentex_sdk/types/state_create_params.py create mode 100644 src/agentex_sdk/types/state_list_params.py create mode 100644 src/agentex_sdk/types/state_list_response.py create mode 100644 src/agentex_sdk/types/state_update_params.py create mode 100644 src/agentex_sdk/types/streaming_status.py create mode 100644 src/agentex_sdk/types/task.py create mode 100644 src/agentex_sdk/types/task_list_response.py create mode 100644 src/agentex_sdk/types/task_message.py create mode 100644 src/agentex_sdk/types/tasks/__init__.py create mode 100644 src/agentex_sdk/types/text_content.py create mode 100644 src/agentex_sdk/types/text_content_param.py create mode 100644 src/agentex_sdk/types/tool_request_content.py create mode 100644 src/agentex_sdk/types/tool_request_content_param.py create mode 100644 src/agentex_sdk/types/tool_response_content.py create mode 100644 src/agentex_sdk/types/tool_response_content_param.py create mode 100644 src/agentex_sdk/types/tracker_list_params.py create mode 100644 src/agentex_sdk/types/tracker_list_response.py create mode 100644 src/agentex_sdk/types/tracker_update_params.py create mode 100644 tests/__init__.py create mode 100644 tests/api_resources/__init__.py create mode 100644 tests/api_resources/agents/__init__.py create mode 100644 tests/api_resources/agents/test_name.py create mode 100644 tests/api_resources/messages/__init__.py create mode 100644 tests/api_resources/messages/test_batch.py create mode 100644 tests/api_resources/tasks/__init__.py create mode 100644 tests/api_resources/tasks/test_name.py create mode 100644 tests/api_resources/test_agents.py create mode 100644 tests/api_resources/test_client.py create mode 100644 tests/api_resources/test_echo.py create mode 100644 tests/api_resources/test_events.py create mode 100644 tests/api_resources/test_messages.py create mode 100644 tests/api_resources/test_spans.py create mode 100644 tests/api_resources/test_states.py create mode 100644 tests/api_resources/test_tasks.py create mode 100644 tests/api_resources/test_tracker.py create mode 100644 tests/conftest.py create mode 100644 tests/sample_file.txt create mode 100644 tests/test_client.py create mode 100644 tests/test_deepcopy.py create mode 100644 tests/test_extract_files.py create mode 100644 tests/test_files.py create mode 100644 tests/test_models.py create mode 100644 tests/test_qs.py create mode 100644 tests/test_required_args.py create mode 100644 tests/test_response.py create mode 100644 tests/test_streaming.py create mode 100644 tests/test_transform.py create mode 100644 tests/test_utils/test_proxy.py create mode 100644 tests/test_utils/test_typing.py create mode 100644 tests/utils.py diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile new file mode 100644 index 00000000..ff261bad --- /dev/null +++ b/.devcontainer/Dockerfile @@ -0,0 +1,9 @@ +ARG VARIANT="3.9" +FROM mcr.microsoft.com/vscode/devcontainers/python:0-${VARIANT} + +USER vscode + +RUN curl -sSf https://rye.astral.sh/get | RYE_VERSION="0.44.0" RYE_INSTALL_OPTION="--yes" bash +ENV PATH=/home/vscode/.rye/shims:$PATH + +RUN echo "[[ -d .venv ]] && source .venv/bin/activate || export PATH=\$PATH" >> /home/vscode/.bashrc diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json new file mode 100644 index 00000000..c17fdc16 --- /dev/null +++ b/.devcontainer/devcontainer.json @@ -0,0 +1,43 @@ +// For format details, see https://aka.ms/devcontainer.json. For config options, see the +// README at: https://github.com/devcontainers/templates/tree/main/src/debian +{ + "name": "Debian", + "build": { + "dockerfile": "Dockerfile", + "context": ".." + }, + + "postStartCommand": "rye sync --all-features", + + "customizations": { + "vscode": { + "extensions": [ + "ms-python.python" + ], + "settings": { + "terminal.integrated.shell.linux": "/bin/bash", + "python.pythonPath": ".venv/bin/python", + "python.defaultInterpreterPath": ".venv/bin/python", + "python.typeChecking": "basic", + "terminal.integrated.env.linux": { + "PATH": "/home/vscode/.rye/shims:${env:PATH}" + } + } + } + }, + "features": { + "ghcr.io/devcontainers/features/node:1": {} + } + + // Features to add to the dev container. More info: https://containers.dev/features. + // "features": {}, + + // Use 'forwardPorts' to make a list of ports inside the container available locally. + // "forwardPorts": [], + + // Configure tool-specific properties. + // "customizations": {}, + + // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root. + // "remoteUser": "root" +} diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 00000000..02569035 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,96 @@ +name: CI +on: + push: + branches-ignore: + - 'generated' + - 'codegen/**' + - 'integrated/**' + - 'stl-preview-head/**' + - 'stl-preview-base/**' + pull_request: + branches-ignore: + - 'stl-preview-head/**' + - 'stl-preview-base/**' + +jobs: + lint: + timeout-minutes: 10 + name: lint + runs-on: ${{ github.repository == 'stainless-sdks/agentex-sdk-python' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }} + if: github.event_name == 'push' || github.event.pull_request.head.repo.fork + steps: + - uses: actions/checkout@v4 + + - name: Install Rye + run: | + curl -sSf https://rye.astral.sh/get | bash + echo "$HOME/.rye/shims" >> $GITHUB_PATH + env: + RYE_VERSION: '0.44.0' + RYE_INSTALL_OPTION: '--yes' + + - name: Install dependencies + run: rye sync --all-features + + - name: Run lints + run: ./scripts/lint + + build: + if: github.repository == 'stainless-sdks/agentex-sdk-python' && (github.event_name == 'push' || github.event.pull_request.head.repo.fork) + timeout-minutes: 10 + name: build + permissions: + contents: read + id-token: write + runs-on: depot-ubuntu-24.04 + steps: + - uses: actions/checkout@v4 + + - name: Install Rye + run: | + curl -sSf https://rye.astral.sh/get | bash + echo "$HOME/.rye/shims" >> $GITHUB_PATH + env: + RYE_VERSION: '0.44.0' + RYE_INSTALL_OPTION: '--yes' + + - name: Install dependencies + run: rye sync --all-features + + - name: Run build + run: rye build + + - name: Get GitHub OIDC Token + id: github-oidc + uses: actions/github-script@v6 + with: + script: core.setOutput('github_token', await core.getIDToken()); + + - name: Upload tarball + env: + URL: https://pkg.stainless.com/s + AUTH: ${{ steps.github-oidc.outputs.github_token }} + SHA: ${{ github.sha }} + run: ./scripts/utils/upload-artifact.sh + + test: + timeout-minutes: 10 + name: test + runs-on: ${{ github.repository == 'stainless-sdks/agentex-sdk-python' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }} + if: github.event_name == 'push' || github.event.pull_request.head.repo.fork + steps: + - uses: actions/checkout@v4 + + - name: Install Rye + run: | + curl -sSf https://rye.astral.sh/get | bash + echo "$HOME/.rye/shims" >> $GITHUB_PATH + env: + RYE_VERSION: '0.44.0' + RYE_INSTALL_OPTION: '--yes' + + - name: Bootstrap + run: ./scripts/bootstrap + + - name: Run tests + run: ./scripts/test diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..87797408 --- /dev/null +++ b/.gitignore @@ -0,0 +1,16 @@ +.prism.log +.vscode +_dev + +__pycache__ +.mypy_cache + +dist + +.venv +.idea + +.env +.envrc +codegen.log +Brewfile.lock.json diff --git a/.python-version b/.python-version new file mode 100644 index 00000000..43077b24 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.9.18 diff --git a/.stats.yml b/.stats.yml new file mode 100644 index 00000000..ee42a924 --- /dev/null +++ b/.stats.yml @@ -0,0 +1,4 @@ +configured_endpoints: 35 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-7a38e3675674c19ea4fa2ca0cfef23aa1d96dbdb29ca3ba4194b0e858d0a4ee0.yml +openapi_spec_hash: 55a7eae5bc606e4ac91841d7e675723e +config_hash: 2efc09afbaa8c5251e880538908bf4de diff --git a/Brewfile b/Brewfile new file mode 100644 index 00000000..492ca37b --- /dev/null +++ b/Brewfile @@ -0,0 +1,2 @@ +brew "rye" + diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 00000000..27a8c1c5 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,128 @@ +## Setting up the environment + +### With Rye + +We use [Rye](https://rye.astral.sh/) to manage dependencies because it will automatically provision a Python environment with the expected Python version. To set it up, run: + +```sh +$ ./scripts/bootstrap +``` + +Or [install Rye manually](https://rye.astral.sh/guide/installation/) and run: + +```sh +$ rye sync --all-features +``` + +You can then run scripts using `rye run python script.py` or by activating the virtual environment: + +```sh +# Activate the virtual environment - https://docs.python.org/3/library/venv.html#how-venvs-work +$ source .venv/bin/activate + +# now you can omit the `rye run` prefix +$ python script.py +``` + +### Without Rye + +Alternatively if you don't want to install `Rye`, you can stick with the standard `pip` setup by ensuring you have the Python version specified in `.python-version`, create a virtual environment however you desire and then install dependencies using this command: + +```sh +$ pip install -r requirements-dev.lock +``` + +## Modifying/Adding code + +Most of the SDK is generated code. Modifications to code will be persisted between generations, but may +result in merge conflicts between manual patches and changes from the generator. The generator will never +modify the contents of the `src/agentex_sdk/lib/` and `examples/` directories. + +## Adding and running examples + +All files in the `examples/` directory are not modified by the generator and can be freely edited or added to. + +```py +# add an example to examples/.py + +#!/usr/bin/env -S rye run python +… +``` + +```sh +$ chmod +x examples/.py +# run the example against your api +$ ./examples/.py +``` + +## Using the repository from source + +If you’d like to use the repository from source, you can either install from git or link to a cloned repository: + +To install via git: + +```sh +$ pip install git+ssh://git@github.com/stainless-sdks/agentex-sdk-python.git +``` + +Alternatively, you can build from source and install the wheel file: + +Building this package will create two files in the `dist/` directory, a `.tar.gz` containing the source files and a `.whl` that can be used to install the package efficiently. + +To create a distributable version of the library, all you have to do is run this command: + +```sh +$ rye build +# or +$ python -m build +``` + +Then to install: + +```sh +$ pip install ./path-to-wheel-file.whl +``` + +## Running tests + +Most tests require you to [set up a mock server](https://github.com/stoplightio/prism) against the OpenAPI spec to run the tests. + +```sh +# you will need npm installed +$ npx prism mock path/to/your/openapi.yml +``` + +```sh +$ ./scripts/test +``` + +## Linting and formatting + +This repository uses [ruff](https://github.com/astral-sh/ruff) and +[black](https://github.com/psf/black) to format the code in the repository. + +To lint: + +```sh +$ ./scripts/lint +``` + +To format and fix all ruff issues automatically: + +```sh +$ ./scripts/format +``` + +## Publishing and releases + +Changes made to this repository via the automated release PR pipeline should publish to PyPI automatically. If +the changes aren't made through the automated pipeline, you may want to make releases manually. + +### Publish with a GitHub workflow + +You can release to package managers by using [the `Publish PyPI` GitHub action](https://www.github.com/stainless-sdks/agentex-sdk-python/actions/workflows/publish-pypi.yml). This requires a setup organization or repository secret to be set up. + +### Publish manually + +If you need to manually release a package, you can run the `bin/publish-pypi` script with a `PYPI_TOKEN` set on +the environment. diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..50c29288 --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2025 Agentex SDK + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md index a23d7055..b42d80fb 100644 --- a/README.md +++ b/README.md @@ -1 +1,379 @@ -# agentex-sdk-python \ No newline at end of file +# Agentex SDK Python API library + + +[![PyPI version](https://img.shields.io/pypi/v/agentex_sdk.svg?label=pypi%20(stable))](https://pypi.org/project/agentex_sdk/) + +The Agentex SDK Python library provides convenient access to the Agentex SDK REST API from any Python 3.8+ +application. The library includes type definitions for all request params and response fields, +and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx). + +It is generated with [Stainless](https://www.stainless.com/). + +## Documentation + +The full API of this library can be found in [api.md](api.md). + +## Installation + +```sh +# install from this staging repo +pip install git+ssh://git@github.com/stainless-sdks/agentex-sdk-python.git +``` + +> [!NOTE] +> Once this package is [published to PyPI](https://www.stainless.com/docs/guides/publish), this will become: `pip install --pre agentex_sdk` + +## Usage + +The full API of this library can be found in [api.md](api.md). + +```python +import os +from agentex_sdk import AgentexSDK + +client = AgentexSDK( + api_key=os.environ.get("AGENTEX_SDK_API_KEY"), # This is the default and can be omitted +) + +response = client.echo.send( + message="message", +) +``` + +While you can provide an `api_key` keyword argument, +we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/) +to add `AGENTEX_SDK_API_KEY="My API Key"` to your `.env` file +so that your API Key is not stored in source control. + +## Async usage + +Simply import `AsyncAgentexSDK` instead of `AgentexSDK` and use `await` with each API call: + +```python +import os +import asyncio +from agentex_sdk import AsyncAgentexSDK + +client = AsyncAgentexSDK( + api_key=os.environ.get("AGENTEX_SDK_API_KEY"), # This is the default and can be omitted +) + + +async def main() -> None: + response = await client.echo.send( + message="message", + ) + + +asyncio.run(main()) +``` + +Functionality between the synchronous and asynchronous clients is otherwise identical. + +### With aiohttp + +By default, the async client uses `httpx` for HTTP requests. However, for improved concurrency performance you may also use `aiohttp` as the HTTP backend. + +You can enable this by installing `aiohttp`: + +```sh +# install from this staging repo +pip install 'agentex_sdk[aiohttp] @ git+ssh://git@github.com/stainless-sdks/agentex-sdk-python.git' +``` + +Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`: + +```python +import asyncio +from agentex_sdk import DefaultAioHttpClient +from agentex_sdk import AsyncAgentexSDK + + +async def main() -> None: + async with AsyncAgentexSDK( + api_key="My API Key", + http_client=DefaultAioHttpClient(), + ) as client: + response = await client.echo.send( + message="message", + ) + + +asyncio.run(main()) +``` + +## Using types + +Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like: + +- Serializing back into JSON, `model.to_json()` +- Converting to a dictionary, `model.to_dict()` + +Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`. + +## Handling errors + +When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `agentex_sdk.APIConnectionError` is raised. + +When the API returns a non-success status code (that is, 4xx or 5xx +response), a subclass of `agentex_sdk.APIStatusError` is raised, containing `status_code` and `response` properties. + +All errors inherit from `agentex_sdk.APIError`. + +```python +import agentex_sdk +from agentex_sdk import AgentexSDK + +client = AgentexSDK() + +try: + client.echo.send( + message="message", + ) +except agentex_sdk.APIConnectionError as e: + print("The server could not be reached") + print(e.__cause__) # an underlying Exception, likely raised within httpx. +except agentex_sdk.RateLimitError as e: + print("A 429 status code was received; we should back off a bit.") +except agentex_sdk.APIStatusError as e: + print("Another non-200-range status code was received") + print(e.status_code) + print(e.response) +``` + +Error codes are as follows: + +| Status Code | Error Type | +| ----------- | -------------------------- | +| 400 | `BadRequestError` | +| 401 | `AuthenticationError` | +| 403 | `PermissionDeniedError` | +| 404 | `NotFoundError` | +| 422 | `UnprocessableEntityError` | +| 429 | `RateLimitError` | +| >=500 | `InternalServerError` | +| N/A | `APIConnectionError` | + +### Retries + +Certain errors are automatically retried 2 times by default, with a short exponential backoff. +Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict, +429 Rate Limit, and >=500 Internal errors are all retried by default. + +You can use the `max_retries` option to configure or disable retry settings: + +```python +from agentex_sdk import AgentexSDK + +# Configure the default for all requests: +client = AgentexSDK( + # default is 2 + max_retries=0, +) + +# Or, configure per-request: +client.with_options(max_retries=5).echo.send( + message="message", +) +``` + +### Timeouts + +By default requests time out after 1 minute. You can configure this with a `timeout` option, +which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/timeouts/#fine-tuning-the-configuration) object: + +```python +from agentex_sdk import AgentexSDK + +# Configure the default for all requests: +client = AgentexSDK( + # 20 seconds (default is 1 minute) + timeout=20.0, +) + +# More granular control: +client = AgentexSDK( + timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0), +) + +# Override per-request: +client.with_options(timeout=5.0).echo.send( + message="message", +) +``` + +On timeout, an `APITimeoutError` is thrown. + +Note that requests that time out are [retried twice by default](#retries). + +## Advanced + +### Logging + +We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module. + +You can enable logging by setting the environment variable `AGENTEX_SDK_LOG` to `info`. + +```shell +$ export AGENTEX_SDK_LOG=info +``` + +Or to `debug` for more verbose logging. + +### How to tell whether `None` means `null` or missing + +In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`: + +```py +if response.my_field is None: + if 'my_field' not in response.model_fields_set: + print('Got json like {}, without a "my_field" key present at all.') + else: + print('Got json like {"my_field": null}.') +``` + +### Accessing raw response data (e.g. headers) + +The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g., + +```py +from agentex_sdk import AgentexSDK + +client = AgentexSDK() +response = client.echo.with_raw_response.send( + message="message", +) +print(response.headers.get('X-My-Header')) + +echo = response.parse() # get the object that `echo.send()` would have returned +print(echo) +``` + +These methods return an [`APIResponse`](https://github.com/stainless-sdks/agentex-sdk-python/tree/main/src/agentex_sdk/_response.py) object. + +The async client returns an [`AsyncAPIResponse`](https://github.com/stainless-sdks/agentex-sdk-python/tree/main/src/agentex_sdk/_response.py) with the same structure, the only difference being `await`able methods for reading the response content. + +#### `.with_streaming_response` + +The above interface eagerly reads the full response body when you make the request, which may not always be what you want. + +To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods. + +```python +with client.echo.with_streaming_response.send( + message="message", +) as response: + print(response.headers.get("X-My-Header")) + + for line in response.iter_lines(): + print(line) +``` + +The context manager is required so that the response will reliably be closed. + +### Making custom/undocumented requests + +This library is typed for convenient access to the documented API. + +If you need to access undocumented endpoints, params, or response properties, the library can still be used. + +#### Undocumented endpoints + +To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other +http verbs. Options on the client will be respected (such as retries) when making this request. + +```py +import httpx + +response = client.post( + "/foo", + cast_to=httpx.Response, + body={"my_param": True}, +) + +print(response.headers.get("x-foo")) +``` + +#### Undocumented request params + +If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request +options. + +#### Undocumented response properties + +To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You +can also get all the extra fields on the Pydantic model as a dict with +[`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra). + +### Configuring the HTTP client + +You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including: + +- Support for [proxies](https://www.python-httpx.org/advanced/proxies/) +- Custom [transports](https://www.python-httpx.org/advanced/transports/) +- Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality + +```python +import httpx +from agentex_sdk import AgentexSDK, DefaultHttpxClient + +client = AgentexSDK( + # Or use the `AGENTEX_SDK_BASE_URL` env var + base_url="http://my.test.server.example.com:8083", + http_client=DefaultHttpxClient( + proxy="http://my.test.proxy.example.com", + transport=httpx.HTTPTransport(local_address="0.0.0.0"), + ), +) +``` + +You can also customize the client on a per-request basis by using `with_options()`: + +```python +client.with_options(http_client=DefaultHttpxClient(...)) +``` + +### Managing HTTP resources + +By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting. + +```py +from agentex_sdk import AgentexSDK + +with AgentexSDK() as client: + # make requests here + ... + +# HTTP client is now closed +``` + +## Versioning + +This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions: + +1. Changes that only affect static types, without breaking runtime behavior. +2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals.)_ +3. Changes that we do not expect to impact the vast majority of users in practice. + +We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience. + +We are keen for your feedback; please open an [issue](https://www.github.com/stainless-sdks/agentex-sdk-python/issues) with questions, bugs, or suggestions. + +### Determining the installed version + +If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version. + +You can determine the version that is being used at runtime with: + +```py +import agentex_sdk +print(agentex_sdk.__version__) +``` + +## Requirements + +Python 3.8 or higher. + +## Contributing + +See [the contributing documentation](./CONTRIBUTING.md). diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 00000000..f4291cc3 --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,23 @@ +# Security Policy + +## Reporting Security Issues + +This SDK is generated by [Stainless Software Inc](http://stainless.com). Stainless takes security seriously, and encourages you to report any security vulnerability promptly so that appropriate action can be taken. + +To report a security issue, please contact the Stainless team at security@stainless.com. + +## Responsible Disclosure + +We appreciate the efforts of security researchers and individuals who help us maintain the security of +SDKs we generate. If you believe you have found a security vulnerability, please adhere to responsible +disclosure practices by allowing us a reasonable amount of time to investigate and address the issue +before making any information public. + +## Reporting Non-SDK Related Security Issues + +If you encounter security issues that are not directly related to SDKs but pertain to the services +or products provided by Agentex SDK, please follow the respective company's security reporting guidelines. + +--- + +Thank you for helping us keep the SDKs and systems they interact with secure. diff --git a/api.md b/api.md new file mode 100644 index 00000000..f3554746 --- /dev/null +++ b/api.md @@ -0,0 +1,152 @@ +# AgentexSDK + +Methods: + +- client.get_root() -> object + +# Echo + +Methods: + +- client.echo.send(\*\*params) -> object + +# Agents + +Types: + +```python +from agentex_sdk.types import AcpType, Agent, AgentRpcRequest, AgentListResponse +``` + +Methods: + +- client.agents.retrieve(agent_id) -> Agent +- client.agents.list(\*\*params) -> AgentListResponse +- client.agents.delete(agent_id) -> Agent +- client.agents.register(\*\*params) -> Agent + +## Name + +Methods: + +- client.agents.name.retrieve(agent_name) -> Agent +- client.agents.name.delete(agent_name) -> Agent + +# Tasks + +Types: + +```python +from agentex_sdk.types import Task, TaskListResponse +``` + +Methods: + +- client.tasks.retrieve(task_id) -> Task +- client.tasks.list() -> TaskListResponse +- client.tasks.delete(task_id) -> Task +- client.tasks.stream_events(task_id) -> object + +## Name + +Methods: + +- client.tasks.name.retrieve(task_name) -> Task +- client.tasks.name.delete(task_name) -> Task +- client.tasks.name.stream_events(task_name) -> object + +# Messages + +Types: + +```python +from agentex_sdk.types import ( + DataContent, + MessageAuthor, + MessageStyle, + StreamingStatus, + TaskMessage, + TextContent, + ToolRequestContent, + ToolResponseContent, + MessageListResponse, +) +``` + +Methods: + +- client.messages.create(\*\*params) -> TaskMessage +- client.messages.retrieve(message_id) -> TaskMessage +- client.messages.update(message_id, \*\*params) -> TaskMessage +- client.messages.list(\*\*params) -> MessageListResponse + +## Batch + +Types: + +```python +from agentex_sdk.types.messages import BatchCreateResponse, BatchUpdateResponse +``` + +Methods: + +- client.messages.batch.create(\*\*params) -> BatchCreateResponse +- client.messages.batch.update(\*\*params) -> BatchUpdateResponse + +# Spans + +Types: + +```python +from agentex_sdk.types import Span, SpanListResponse +``` + +Methods: + +- client.spans.create(\*\*params) -> Span +- client.spans.retrieve(span_id) -> Span +- client.spans.update(span_id, \*\*params) -> Span +- client.spans.list(\*\*params) -> SpanListResponse + +# States + +Types: + +```python +from agentex_sdk.types import State, StateListResponse +``` + +Methods: + +- client.states.create(\*\*params) -> State +- client.states.retrieve(state_id) -> State +- client.states.update(state_id, \*\*params) -> State +- client.states.list(\*\*params) -> StateListResponse +- client.states.delete(state_id) -> State + +# Events + +Types: + +```python +from agentex_sdk.types import Event, EventListResponse +``` + +Methods: + +- client.events.retrieve(event_id) -> Event +- client.events.list(\*\*params) -> EventListResponse + +# Tracker + +Types: + +```python +from agentex_sdk.types import AgentTaskTracker, TrackerListResponse +``` + +Methods: + +- client.tracker.retrieve(tracker_id) -> AgentTaskTracker +- client.tracker.update(tracker_id, \*\*params) -> AgentTaskTracker +- client.tracker.list(\*\*params) -> TrackerListResponse diff --git a/bin/publish-pypi b/bin/publish-pypi new file mode 100644 index 00000000..826054e9 --- /dev/null +++ b/bin/publish-pypi @@ -0,0 +1,6 @@ +#!/usr/bin/env bash + +set -eux +mkdir -p dist +rye build --clean +rye publish --yes --token=$PYPI_TOKEN diff --git a/examples/.keep b/examples/.keep new file mode 100644 index 00000000..d8c73e93 --- /dev/null +++ b/examples/.keep @@ -0,0 +1,4 @@ +File generated from our OpenAPI spec by Stainless. + +This directory can be used to store example files demonstrating usage of this SDK. +It is ignored by Stainless code generation and its content (other than this keep file) won't be touched. \ No newline at end of file diff --git a/mypy.ini b/mypy.ini new file mode 100644 index 00000000..5af2c510 --- /dev/null +++ b/mypy.ini @@ -0,0 +1,50 @@ +[mypy] +pretty = True +show_error_codes = True + +# Exclude _files.py because mypy isn't smart enough to apply +# the correct type narrowing and as this is an internal module +# it's fine to just use Pyright. +# +# We also exclude our `tests` as mypy doesn't always infer +# types correctly and Pyright will still catch any type errors. +exclude = ^(src/agentex_sdk/_files\.py|_dev/.*\.py|tests/.*)$ + +strict_equality = True +implicit_reexport = True +check_untyped_defs = True +no_implicit_optional = True + +warn_return_any = True +warn_unreachable = True +warn_unused_configs = True + +# Turn these options off as it could cause conflicts +# with the Pyright options. +warn_unused_ignores = False +warn_redundant_casts = False + +disallow_any_generics = True +disallow_untyped_defs = True +disallow_untyped_calls = True +disallow_subclassing_any = True +disallow_incomplete_defs = True +disallow_untyped_decorators = True +cache_fine_grained = True + +# By default, mypy reports an error if you assign a value to the result +# of a function call that doesn't return anything. We do this in our test +# cases: +# ``` +# result = ... +# assert result is None +# ``` +# Changing this codegen to make mypy happy would increase complexity +# and would not be worth it. +disable_error_code = func-returns-value,overload-cannot-match + +# https://github.com/python/mypy/issues/12162 +[mypy.overrides] +module = "black.files.*" +ignore_errors = true +ignore_missing_imports = true diff --git a/noxfile.py b/noxfile.py new file mode 100644 index 00000000..53bca7ff --- /dev/null +++ b/noxfile.py @@ -0,0 +1,9 @@ +import nox + + +@nox.session(reuse_venv=True, name="test-pydantic-v1") +def test_pydantic_v1(session: nox.Session) -> None: + session.install("-r", "requirements-dev.lock") + session.install("pydantic<2") + + session.run("pytest", "--showlocals", "--ignore=tests/functional", *session.posargs) diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..3d289ba7 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,211 @@ +[project] +name = "agentex_sdk" +version = "0.0.1-alpha.0" +description = "The official Python library for the agentex-sdk API" +dynamic = ["readme"] +license = "Apache-2.0" +authors = [ +{ name = "Agentex SDK", email = "" }, +] +dependencies = [ + "httpx>=0.23.0, <1", + "pydantic>=1.9.0, <3", + "typing-extensions>=4.10, <5", + "anyio>=3.5.0, <5", + "distro>=1.7.0, <2", + "sniffio", +] +requires-python = ">= 3.8" +classifiers = [ + "Typing :: Typed", + "Intended Audience :: Developers", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Operating System :: OS Independent", + "Operating System :: POSIX", + "Operating System :: MacOS", + "Operating System :: POSIX :: Linux", + "Operating System :: Microsoft :: Windows", + "Topic :: Software Development :: Libraries :: Python Modules", + "License :: OSI Approved :: Apache Software License" +] + +[project.urls] +Homepage = "https://github.com/stainless-sdks/agentex-sdk-python" +Repository = "https://github.com/stainless-sdks/agentex-sdk-python" + +[project.optional-dependencies] +aiohttp = ["aiohttp", "httpx_aiohttp>=0.1.8"] + +[tool.rye] +managed = true +# version pins are in requirements-dev.lock +dev-dependencies = [ + "pyright==1.1.399", + "mypy", + "respx", + "pytest", + "pytest-asyncio", + "ruff", + "time-machine", + "nox", + "dirty-equals>=0.6.0", + "importlib-metadata>=6.7.0", + "rich>=13.7.1", + "nest_asyncio==1.6.0", + "pytest-xdist>=3.6.1", +] + +[tool.rye.scripts] +format = { chain = [ + "format:ruff", + "format:docs", + "fix:ruff", + # run formatting again to fix any inconsistencies when imports are stripped + "format:ruff", +]} +"format:docs" = "python scripts/utils/ruffen-docs.py README.md api.md" +"format:ruff" = "ruff format" + +"lint" = { chain = [ + "check:ruff", + "typecheck", + "check:importable", +]} +"check:ruff" = "ruff check ." +"fix:ruff" = "ruff check --fix ." + +"check:importable" = "python -c 'import agentex_sdk'" + +typecheck = { chain = [ + "typecheck:pyright", + "typecheck:mypy" +]} +"typecheck:pyright" = "pyright" +"typecheck:verify-types" = "pyright --verifytypes agentex_sdk --ignoreexternal" +"typecheck:mypy" = "mypy ." + +[build-system] +requires = ["hatchling==1.26.3", "hatch-fancy-pypi-readme"] +build-backend = "hatchling.build" + +[tool.hatch.build] +include = [ + "src/*" +] + +[tool.hatch.build.targets.wheel] +packages = ["src/agentex_sdk"] + +[tool.hatch.build.targets.sdist] +# Basically everything except hidden files/directories (such as .github, .devcontainers, .python-version, etc) +include = [ + "/*.toml", + "/*.json", + "/*.lock", + "/*.md", + "/mypy.ini", + "/noxfile.py", + "bin/*", + "examples/*", + "src/*", + "tests/*", +] + +[tool.hatch.metadata.hooks.fancy-pypi-readme] +content-type = "text/markdown" + +[[tool.hatch.metadata.hooks.fancy-pypi-readme.fragments]] +path = "README.md" + +[[tool.hatch.metadata.hooks.fancy-pypi-readme.substitutions]] +# replace relative links with absolute links +pattern = '\[(.+?)\]\(((?!https?://)\S+?)\)' +replacement = '[\1](https://github.com/stainless-sdks/agentex-sdk-python/tree/main/\g<2>)' + +[tool.pytest.ini_options] +testpaths = ["tests"] +addopts = "--tb=short -n auto" +xfail_strict = true +asyncio_mode = "auto" +asyncio_default_fixture_loop_scope = "session" +filterwarnings = [ + "error" +] + +[tool.pyright] +# this enables practically every flag given by pyright. +# there are a couple of flags that are still disabled by +# default in strict mode as they are experimental and niche. +typeCheckingMode = "strict" +pythonVersion = "3.8" + +exclude = [ + "_dev", + ".venv", + ".nox", +] + +reportImplicitOverride = true +reportOverlappingOverload = false + +reportImportCycles = false +reportPrivateUsage = false + +[tool.ruff] +line-length = 120 +output-format = "grouped" +target-version = "py37" + +[tool.ruff.format] +docstring-code-format = true + +[tool.ruff.lint] +select = [ + # isort + "I", + # bugbear rules + "B", + # remove unused imports + "F401", + # bare except statements + "E722", + # unused arguments + "ARG", + # print statements + "T201", + "T203", + # misuse of typing.TYPE_CHECKING + "TC004", + # import rules + "TID251", +] +ignore = [ + # mutable defaults + "B006", +] +unfixable = [ + # disable auto fix for print statements + "T201", + "T203", +] + +[tool.ruff.lint.flake8-tidy-imports.banned-api] +"functools.lru_cache".msg = "This function does not retain type information for the wrapped function's arguments; The `lru_cache` function from `_utils` should be used instead" + +[tool.ruff.lint.isort] +length-sort = true +length-sort-straight = true +combine-as-imports = true +extra-standard-library = ["typing_extensions"] +known-first-party = ["agentex_sdk", "tests"] + +[tool.ruff.lint.per-file-ignores] +"bin/**.py" = ["T201", "T203"] +"scripts/**.py" = ["T201", "T203"] +"tests/**.py" = ["T201", "T203"] +"examples/**.py" = ["T201", "T203"] diff --git a/requirements-dev.lock b/requirements-dev.lock new file mode 100644 index 00000000..56a38441 --- /dev/null +++ b/requirements-dev.lock @@ -0,0 +1,135 @@ +# generated by rye +# use `rye lock` or `rye sync` to update this lockfile +# +# last locked with the following flags: +# pre: false +# features: [] +# all-features: true +# with-sources: false +# generate-hashes: false +# universal: false + +-e file:. +aiohappyeyeballs==2.6.1 + # via aiohttp +aiohttp==3.12.8 + # via agentex-sdk + # via httpx-aiohttp +aiosignal==1.3.2 + # via aiohttp +annotated-types==0.6.0 + # via pydantic +anyio==4.4.0 + # via agentex-sdk + # via httpx +argcomplete==3.1.2 + # via nox +async-timeout==5.0.1 + # via aiohttp +attrs==25.3.0 + # via aiohttp +certifi==2023.7.22 + # via httpcore + # via httpx +colorlog==6.7.0 + # via nox +dirty-equals==0.6.0 +distlib==0.3.7 + # via virtualenv +distro==1.8.0 + # via agentex-sdk +exceptiongroup==1.2.2 + # via anyio + # via pytest +execnet==2.1.1 + # via pytest-xdist +filelock==3.12.4 + # via virtualenv +frozenlist==1.6.2 + # via aiohttp + # via aiosignal +h11==0.16.0 + # via httpcore +httpcore==1.0.9 + # via httpx +httpx==0.28.1 + # via agentex-sdk + # via httpx-aiohttp + # via respx +httpx-aiohttp==0.1.8 + # via agentex-sdk +idna==3.4 + # via anyio + # via httpx + # via yarl +importlib-metadata==7.0.0 +iniconfig==2.0.0 + # via pytest +markdown-it-py==3.0.0 + # via rich +mdurl==0.1.2 + # via markdown-it-py +multidict==6.4.4 + # via aiohttp + # via yarl +mypy==1.14.1 +mypy-extensions==1.0.0 + # via mypy +nest-asyncio==1.6.0 +nodeenv==1.8.0 + # via pyright +nox==2023.4.22 +packaging==23.2 + # via nox + # via pytest +platformdirs==3.11.0 + # via virtualenv +pluggy==1.5.0 + # via pytest +propcache==0.3.1 + # via aiohttp + # via yarl +pydantic==2.10.3 + # via agentex-sdk +pydantic-core==2.27.1 + # via pydantic +pygments==2.18.0 + # via rich +pyright==1.1.399 +pytest==8.3.3 + # via pytest-asyncio + # via pytest-xdist +pytest-asyncio==0.24.0 +pytest-xdist==3.7.0 +python-dateutil==2.8.2 + # via time-machine +pytz==2023.3.post1 + # via dirty-equals +respx==0.22.0 +rich==13.7.1 +ruff==0.9.4 +setuptools==68.2.2 + # via nodeenv +six==1.16.0 + # via python-dateutil +sniffio==1.3.0 + # via agentex-sdk + # via anyio +time-machine==2.9.0 +tomli==2.0.2 + # via mypy + # via pytest +typing-extensions==4.12.2 + # via agentex-sdk + # via anyio + # via multidict + # via mypy + # via pydantic + # via pydantic-core + # via pyright +virtualenv==20.24.5 + # via nox +yarl==1.20.0 + # via aiohttp +zipp==3.17.0 + # via importlib-metadata diff --git a/requirements.lock b/requirements.lock new file mode 100644 index 00000000..a4e7e943 --- /dev/null +++ b/requirements.lock @@ -0,0 +1,72 @@ +# generated by rye +# use `rye lock` or `rye sync` to update this lockfile +# +# last locked with the following flags: +# pre: false +# features: [] +# all-features: true +# with-sources: false +# generate-hashes: false +# universal: false + +-e file:. +aiohappyeyeballs==2.6.1 + # via aiohttp +aiohttp==3.12.8 + # via agentex-sdk + # via httpx-aiohttp +aiosignal==1.3.2 + # via aiohttp +annotated-types==0.6.0 + # via pydantic +anyio==4.4.0 + # via agentex-sdk + # via httpx +async-timeout==5.0.1 + # via aiohttp +attrs==25.3.0 + # via aiohttp +certifi==2023.7.22 + # via httpcore + # via httpx +distro==1.8.0 + # via agentex-sdk +exceptiongroup==1.2.2 + # via anyio +frozenlist==1.6.2 + # via aiohttp + # via aiosignal +h11==0.16.0 + # via httpcore +httpcore==1.0.9 + # via httpx +httpx==0.28.1 + # via agentex-sdk + # via httpx-aiohttp +httpx-aiohttp==0.1.8 + # via agentex-sdk +idna==3.4 + # via anyio + # via httpx + # via yarl +multidict==6.4.4 + # via aiohttp + # via yarl +propcache==0.3.1 + # via aiohttp + # via yarl +pydantic==2.10.3 + # via agentex-sdk +pydantic-core==2.27.1 + # via pydantic +sniffio==1.3.0 + # via agentex-sdk + # via anyio +typing-extensions==4.12.2 + # via agentex-sdk + # via anyio + # via multidict + # via pydantic + # via pydantic-core +yarl==1.20.0 + # via aiohttp diff --git a/scripts/bootstrap b/scripts/bootstrap new file mode 100755 index 00000000..e84fe62c --- /dev/null +++ b/scripts/bootstrap @@ -0,0 +1,19 @@ +#!/usr/bin/env bash + +set -e + +cd "$(dirname "$0")/.." + +if ! command -v rye >/dev/null 2>&1 && [ -f "Brewfile" ] && [ "$(uname -s)" = "Darwin" ]; then + brew bundle check >/dev/null 2>&1 || { + echo "==> Installing Homebrew dependencies…" + brew bundle + } +fi + +echo "==> Installing Python dependencies…" + +# experimental uv support makes installations significantly faster +rye config --set-bool behavior.use-uv=true + +rye sync --all-features diff --git a/scripts/format b/scripts/format new file mode 100755 index 00000000..667ec2d7 --- /dev/null +++ b/scripts/format @@ -0,0 +1,8 @@ +#!/usr/bin/env bash + +set -e + +cd "$(dirname "$0")/.." + +echo "==> Running formatters" +rye run format diff --git a/scripts/lint b/scripts/lint new file mode 100755 index 00000000..3788432a --- /dev/null +++ b/scripts/lint @@ -0,0 +1,11 @@ +#!/usr/bin/env bash + +set -e + +cd "$(dirname "$0")/.." + +echo "==> Running lints" +rye run lint + +echo "==> Making sure it imports" +rye run python -c 'import agentex_sdk' diff --git a/scripts/mock b/scripts/mock new file mode 100755 index 00000000..d2814ae6 --- /dev/null +++ b/scripts/mock @@ -0,0 +1,41 @@ +#!/usr/bin/env bash + +set -e + +cd "$(dirname "$0")/.." + +if [[ -n "$1" && "$1" != '--'* ]]; then + URL="$1" + shift +else + URL="$(grep 'openapi_spec_url' .stats.yml | cut -d' ' -f2)" +fi + +# Check if the URL is empty +if [ -z "$URL" ]; then + echo "Error: No OpenAPI spec path/url provided or found in .stats.yml" + exit 1 +fi + +echo "==> Starting mock server with URL ${URL}" + +# Run prism mock on the given spec +if [ "$1" == "--daemon" ]; then + npm exec --package=@stainless-api/prism-cli@5.8.5 -- prism mock "$URL" &> .prism.log & + + # Wait for server to come online + echo -n "Waiting for server" + while ! grep -q "✖ fatal\|Prism is listening" ".prism.log" ; do + echo -n "." + sleep 0.1 + done + + if grep -q "✖ fatal" ".prism.log"; then + cat .prism.log + exit 1 + fi + + echo +else + npm exec --package=@stainless-api/prism-cli@5.8.5 -- prism mock "$URL" +fi diff --git a/scripts/test b/scripts/test new file mode 100755 index 00000000..2b878456 --- /dev/null +++ b/scripts/test @@ -0,0 +1,61 @@ +#!/usr/bin/env bash + +set -e + +cd "$(dirname "$0")/.." + +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[0;33m' +NC='\033[0m' # No Color + +function prism_is_running() { + curl --silent "http://localhost:4010" >/dev/null 2>&1 +} + +kill_server_on_port() { + pids=$(lsof -t -i tcp:"$1" || echo "") + if [ "$pids" != "" ]; then + kill "$pids" + echo "Stopped $pids." + fi +} + +function is_overriding_api_base_url() { + [ -n "$TEST_API_BASE_URL" ] +} + +if ! is_overriding_api_base_url && ! prism_is_running ; then + # When we exit this script, make sure to kill the background mock server process + trap 'kill_server_on_port 4010' EXIT + + # Start the dev server + ./scripts/mock --daemon +fi + +if is_overriding_api_base_url ; then + echo -e "${GREEN}✔ Running tests against ${TEST_API_BASE_URL}${NC}" + echo +elif ! prism_is_running ; then + echo -e "${RED}ERROR:${NC} The test suite will not run without a mock Prism server" + echo -e "running against your OpenAPI spec." + echo + echo -e "To run the server, pass in the path or url of your OpenAPI" + echo -e "spec to the prism command:" + echo + echo -e " \$ ${YELLOW}npm exec --package=@stoplight/prism-cli@~5.3.2 -- prism mock path/to/your.openapi.yml${NC}" + echo + + exit 1 +else + echo -e "${GREEN}✔ Mock prism server is running with your OpenAPI spec${NC}" + echo +fi + +export DEFER_PYDANTIC_BUILD=false + +echo "==> Running tests" +rye run pytest "$@" + +echo "==> Running Pydantic v1 tests" +rye run nox -s test-pydantic-v1 -- "$@" diff --git a/scripts/utils/ruffen-docs.py b/scripts/utils/ruffen-docs.py new file mode 100644 index 00000000..0cf2bd2f --- /dev/null +++ b/scripts/utils/ruffen-docs.py @@ -0,0 +1,167 @@ +# fork of https://github.com/asottile/blacken-docs adapted for ruff +from __future__ import annotations + +import re +import sys +import argparse +import textwrap +import contextlib +import subprocess +from typing import Match, Optional, Sequence, Generator, NamedTuple, cast + +MD_RE = re.compile( + r"(?P^(?P *)```\s*python\n)" r"(?P.*?)" r"(?P^(?P=indent)```\s*$)", + re.DOTALL | re.MULTILINE, +) +MD_PYCON_RE = re.compile( + r"(?P^(?P *)```\s*pycon\n)" r"(?P.*?)" r"(?P^(?P=indent)```.*$)", + re.DOTALL | re.MULTILINE, +) +PYCON_PREFIX = ">>> " +PYCON_CONTINUATION_PREFIX = "..." +PYCON_CONTINUATION_RE = re.compile( + rf"^{re.escape(PYCON_CONTINUATION_PREFIX)}( |$)", +) +DEFAULT_LINE_LENGTH = 100 + + +class CodeBlockError(NamedTuple): + offset: int + exc: Exception + + +def format_str( + src: str, +) -> tuple[str, Sequence[CodeBlockError]]: + errors: list[CodeBlockError] = [] + + @contextlib.contextmanager + def _collect_error(match: Match[str]) -> Generator[None, None, None]: + try: + yield + except Exception as e: + errors.append(CodeBlockError(match.start(), e)) + + def _md_match(match: Match[str]) -> str: + code = textwrap.dedent(match["code"]) + with _collect_error(match): + code = format_code_block(code) + code = textwrap.indent(code, match["indent"]) + return f"{match['before']}{code}{match['after']}" + + def _pycon_match(match: Match[str]) -> str: + code = "" + fragment = cast(Optional[str], None) + + def finish_fragment() -> None: + nonlocal code + nonlocal fragment + + if fragment is not None: + with _collect_error(match): + fragment = format_code_block(fragment) + fragment_lines = fragment.splitlines() + code += f"{PYCON_PREFIX}{fragment_lines[0]}\n" + for line in fragment_lines[1:]: + # Skip blank lines to handle Black adding a blank above + # functions within blocks. A blank line would end the REPL + # continuation prompt. + # + # >>> if True: + # ... def f(): + # ... pass + # ... + if line: + code += f"{PYCON_CONTINUATION_PREFIX} {line}\n" + if fragment_lines[-1].startswith(" "): + code += f"{PYCON_CONTINUATION_PREFIX}\n" + fragment = None + + indentation = None + for line in match["code"].splitlines(): + orig_line, line = line, line.lstrip() + if indentation is None and line: + indentation = len(orig_line) - len(line) + continuation_match = PYCON_CONTINUATION_RE.match(line) + if continuation_match and fragment is not None: + fragment += line[continuation_match.end() :] + "\n" + else: + finish_fragment() + if line.startswith(PYCON_PREFIX): + fragment = line[len(PYCON_PREFIX) :] + "\n" + else: + code += orig_line[indentation:] + "\n" + finish_fragment() + return code + + def _md_pycon_match(match: Match[str]) -> str: + code = _pycon_match(match) + code = textwrap.indent(code, match["indent"]) + return f"{match['before']}{code}{match['after']}" + + src = MD_RE.sub(_md_match, src) + src = MD_PYCON_RE.sub(_md_pycon_match, src) + return src, errors + + +def format_code_block(code: str) -> str: + return subprocess.check_output( + [ + sys.executable, + "-m", + "ruff", + "format", + "--stdin-filename=script.py", + f"--line-length={DEFAULT_LINE_LENGTH}", + ], + encoding="utf-8", + input=code, + ) + + +def format_file( + filename: str, + skip_errors: bool, +) -> int: + with open(filename, encoding="UTF-8") as f: + contents = f.read() + new_contents, errors = format_str(contents) + for error in errors: + lineno = contents[: error.offset].count("\n") + 1 + print(f"{filename}:{lineno}: code block parse error {error.exc}") + if errors and not skip_errors: + return 1 + if contents != new_contents: + print(f"{filename}: Rewriting...") + with open(filename, "w", encoding="UTF-8") as f: + f.write(new_contents) + return 0 + else: + return 0 + + +def main(argv: Sequence[str] | None = None) -> int: + parser = argparse.ArgumentParser() + parser.add_argument( + "-l", + "--line-length", + type=int, + default=DEFAULT_LINE_LENGTH, + ) + parser.add_argument( + "-S", + "--skip-string-normalization", + action="store_true", + ) + parser.add_argument("-E", "--skip-errors", action="store_true") + parser.add_argument("filenames", nargs="*") + args = parser.parse_args(argv) + + retv = 0 + for filename in args.filenames: + retv |= format_file(filename, skip_errors=args.skip_errors) + return retv + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/utils/upload-artifact.sh b/scripts/utils/upload-artifact.sh new file mode 100755 index 00000000..e766fabe --- /dev/null +++ b/scripts/utils/upload-artifact.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash +set -exuo pipefail + +FILENAME=$(basename dist/*.whl) + +RESPONSE=$(curl -X POST "$URL?filename=$FILENAME" \ + -H "Authorization: Bearer $AUTH" \ + -H "Content-Type: application/json") + +SIGNED_URL=$(echo "$RESPONSE" | jq -r '.url') + +if [[ "$SIGNED_URL" == "null" ]]; then + echo -e "\033[31mFailed to get signed URL.\033[0m" + exit 1 +fi + +UPLOAD_RESPONSE=$(curl -v -X PUT \ + -H "Content-Type: binary/octet-stream" \ + --data-binary "@dist/$FILENAME" "$SIGNED_URL" 2>&1) + +if echo "$UPLOAD_RESPONSE" | grep -q "HTTP/[0-9.]* 200"; then + echo -e "\033[32mUploaded build to Stainless storage.\033[0m" + echo -e "\033[32mInstallation: pip install 'https://pkg.stainless.com/s/agentex-sdk-python/$SHA/$FILENAME'\033[0m" +else + echo -e "\033[31mFailed to upload artifact.\033[0m" + exit 1 +fi diff --git a/src/agentex_sdk/__init__.py b/src/agentex_sdk/__init__.py new file mode 100644 index 00000000..6f29658e --- /dev/null +++ b/src/agentex_sdk/__init__.py @@ -0,0 +1,100 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import typing as _t + +from . import types +from ._types import NOT_GIVEN, Omit, NoneType, NotGiven, Transport, ProxiesTypes +from ._utils import file_from_path +from ._client import ( + Client, + Stream, + Timeout, + Transport, + AgentexSDK, + AsyncClient, + AsyncStream, + RequestOptions, + AsyncAgentexSDK, +) +from ._models import BaseModel +from ._version import __title__, __version__ +from ._response import APIResponse as APIResponse, AsyncAPIResponse as AsyncAPIResponse +from ._constants import DEFAULT_TIMEOUT, DEFAULT_MAX_RETRIES, DEFAULT_CONNECTION_LIMITS +from ._exceptions import ( + APIError, + ConflictError, + NotFoundError, + APIStatusError, + RateLimitError, + AgentexSDKError, + APITimeoutError, + BadRequestError, + APIConnectionError, + AuthenticationError, + InternalServerError, + PermissionDeniedError, + UnprocessableEntityError, + APIResponseValidationError, +) +from ._base_client import DefaultHttpxClient, DefaultAioHttpClient, DefaultAsyncHttpxClient +from ._utils._logs import setup_logging as _setup_logging + +__all__ = [ + "types", + "__version__", + "__title__", + "NoneType", + "Transport", + "ProxiesTypes", + "NotGiven", + "NOT_GIVEN", + "Omit", + "AgentexSDKError", + "APIError", + "APIStatusError", + "APITimeoutError", + "APIConnectionError", + "APIResponseValidationError", + "BadRequestError", + "AuthenticationError", + "PermissionDeniedError", + "NotFoundError", + "ConflictError", + "UnprocessableEntityError", + "RateLimitError", + "InternalServerError", + "Timeout", + "RequestOptions", + "Client", + "AsyncClient", + "Stream", + "AsyncStream", + "AgentexSDK", + "AsyncAgentexSDK", + "file_from_path", + "BaseModel", + "DEFAULT_TIMEOUT", + "DEFAULT_MAX_RETRIES", + "DEFAULT_CONNECTION_LIMITS", + "DefaultHttpxClient", + "DefaultAsyncHttpxClient", + "DefaultAioHttpClient", +] + +if not _t.TYPE_CHECKING: + from ._utils._resources_proxy import resources as resources + +_setup_logging() + +# Update the __module__ attribute for exported symbols so that +# error messages point to this module instead of the module +# it was originally defined in, e.g. +# agentex_sdk._exceptions.NotFoundError -> agentex_sdk.NotFoundError +__locals = locals() +for __name in __all__: + if not __name.startswith("__"): + try: + __locals[__name].__module__ = "agentex_sdk" + except (TypeError, AttributeError): + # Some of our exported symbols are builtins which we can't set attributes for. + pass diff --git a/src/agentex_sdk/_base_client.py b/src/agentex_sdk/_base_client.py new file mode 100644 index 00000000..a68e0526 --- /dev/null +++ b/src/agentex_sdk/_base_client.py @@ -0,0 +1,1992 @@ +from __future__ import annotations + +import sys +import json +import time +import uuid +import email +import asyncio +import inspect +import logging +import platform +import email.utils +from types import TracebackType +from random import random +from typing import ( + TYPE_CHECKING, + Any, + Dict, + Type, + Union, + Generic, + Mapping, + TypeVar, + Iterable, + Iterator, + Optional, + Generator, + AsyncIterator, + cast, + overload, +) +from typing_extensions import Literal, override, get_origin + +import anyio +import httpx +import distro +import pydantic +from httpx import URL +from pydantic import PrivateAttr + +from . import _exceptions +from ._qs import Querystring +from ._files import to_httpx_files, async_to_httpx_files +from ._types import ( + NOT_GIVEN, + Body, + Omit, + Query, + Headers, + Timeout, + NotGiven, + ResponseT, + AnyMapping, + PostParser, + RequestFiles, + HttpxSendArgs, + RequestOptions, + HttpxRequestFiles, + ModelBuilderProtocol, +) +from ._utils import is_dict, is_list, asyncify, is_given, lru_cache, is_mapping +from ._compat import PYDANTIC_V2, model_copy, model_dump +from ._models import GenericModel, FinalRequestOptions, validate_type, construct_type +from ._response import ( + APIResponse, + BaseAPIResponse, + AsyncAPIResponse, + extract_response_type, +) +from ._constants import ( + DEFAULT_TIMEOUT, + MAX_RETRY_DELAY, + DEFAULT_MAX_RETRIES, + INITIAL_RETRY_DELAY, + RAW_RESPONSE_HEADER, + OVERRIDE_CAST_TO_HEADER, + DEFAULT_CONNECTION_LIMITS, +) +from ._streaming import Stream, SSEDecoder, AsyncStream, SSEBytesDecoder +from ._exceptions import ( + APIStatusError, + APITimeoutError, + APIConnectionError, + APIResponseValidationError, +) + +log: logging.Logger = logging.getLogger(__name__) + +# TODO: make base page type vars covariant +SyncPageT = TypeVar("SyncPageT", bound="BaseSyncPage[Any]") +AsyncPageT = TypeVar("AsyncPageT", bound="BaseAsyncPage[Any]") + + +_T = TypeVar("_T") +_T_co = TypeVar("_T_co", covariant=True) + +_StreamT = TypeVar("_StreamT", bound=Stream[Any]) +_AsyncStreamT = TypeVar("_AsyncStreamT", bound=AsyncStream[Any]) + +if TYPE_CHECKING: + from httpx._config import ( + DEFAULT_TIMEOUT_CONFIG, # pyright: ignore[reportPrivateImportUsage] + ) + + HTTPX_DEFAULT_TIMEOUT = DEFAULT_TIMEOUT_CONFIG +else: + try: + from httpx._config import DEFAULT_TIMEOUT_CONFIG as HTTPX_DEFAULT_TIMEOUT + except ImportError: + # taken from https://github.com/encode/httpx/blob/3ba5fe0d7ac70222590e759c31442b1cab263791/httpx/_config.py#L366 + HTTPX_DEFAULT_TIMEOUT = Timeout(5.0) + + +class PageInfo: + """Stores the necessary information to build the request to retrieve the next page. + + Either `url` or `params` must be set. + """ + + url: URL | NotGiven + params: Query | NotGiven + json: Body | NotGiven + + @overload + def __init__( + self, + *, + url: URL, + ) -> None: ... + + @overload + def __init__( + self, + *, + params: Query, + ) -> None: ... + + @overload + def __init__( + self, + *, + json: Body, + ) -> None: ... + + def __init__( + self, + *, + url: URL | NotGiven = NOT_GIVEN, + json: Body | NotGiven = NOT_GIVEN, + params: Query | NotGiven = NOT_GIVEN, + ) -> None: + self.url = url + self.json = json + self.params = params + + @override + def __repr__(self) -> str: + if self.url: + return f"{self.__class__.__name__}(url={self.url})" + if self.json: + return f"{self.__class__.__name__}(json={self.json})" + return f"{self.__class__.__name__}(params={self.params})" + + +class BasePage(GenericModel, Generic[_T]): + """ + Defines the core interface for pagination. + + Type Args: + ModelT: The pydantic model that represents an item in the response. + + Methods: + has_next_page(): Check if there is another page available + next_page_info(): Get the necessary information to make a request for the next page + """ + + _options: FinalRequestOptions = PrivateAttr() + _model: Type[_T] = PrivateAttr() + + def has_next_page(self) -> bool: + items = self._get_page_items() + if not items: + return False + return self.next_page_info() is not None + + def next_page_info(self) -> Optional[PageInfo]: ... + + def _get_page_items(self) -> Iterable[_T]: # type: ignore[empty-body] + ... + + def _params_from_url(self, url: URL) -> httpx.QueryParams: + # TODO: do we have to preprocess params here? + return httpx.QueryParams(cast(Any, self._options.params)).merge(url.params) + + def _info_to_options(self, info: PageInfo) -> FinalRequestOptions: + options = model_copy(self._options) + options._strip_raw_response_header() + + if not isinstance(info.params, NotGiven): + options.params = {**options.params, **info.params} + return options + + if not isinstance(info.url, NotGiven): + params = self._params_from_url(info.url) + url = info.url.copy_with(params=params) + options.params = dict(url.params) + options.url = str(url) + return options + + if not isinstance(info.json, NotGiven): + if not is_mapping(info.json): + raise TypeError("Pagination is only supported with mappings") + + if not options.json_data: + options.json_data = {**info.json} + else: + if not is_mapping(options.json_data): + raise TypeError("Pagination is only supported with mappings") + + options.json_data = {**options.json_data, **info.json} + return options + + raise ValueError("Unexpected PageInfo state") + + +class BaseSyncPage(BasePage[_T], Generic[_T]): + _client: SyncAPIClient = pydantic.PrivateAttr() + + def _set_private_attributes( + self, + client: SyncAPIClient, + model: Type[_T], + options: FinalRequestOptions, + ) -> None: + if PYDANTIC_V2 and getattr(self, "__pydantic_private__", None) is None: + self.__pydantic_private__ = {} + + self._model = model + self._client = client + self._options = options + + # Pydantic uses a custom `__iter__` method to support casting BaseModels + # to dictionaries. e.g. dict(model). + # As we want to support `for item in page`, this is inherently incompatible + # with the default pydantic behaviour. It is not possible to support both + # use cases at once. Fortunately, this is not a big deal as all other pydantic + # methods should continue to work as expected as there is an alternative method + # to cast a model to a dictionary, model.dict(), which is used internally + # by pydantic. + def __iter__(self) -> Iterator[_T]: # type: ignore + for page in self.iter_pages(): + for item in page._get_page_items(): + yield item + + def iter_pages(self: SyncPageT) -> Iterator[SyncPageT]: + page = self + while True: + yield page + if page.has_next_page(): + page = page.get_next_page() + else: + return + + def get_next_page(self: SyncPageT) -> SyncPageT: + info = self.next_page_info() + if not info: + raise RuntimeError( + "No next page expected; please check `.has_next_page()` before calling `.get_next_page()`." + ) + + options = self._info_to_options(info) + return self._client._request_api_list(self._model, page=self.__class__, options=options) + + +class AsyncPaginator(Generic[_T, AsyncPageT]): + def __init__( + self, + client: AsyncAPIClient, + options: FinalRequestOptions, + page_cls: Type[AsyncPageT], + model: Type[_T], + ) -> None: + self._model = model + self._client = client + self._options = options + self._page_cls = page_cls + + def __await__(self) -> Generator[Any, None, AsyncPageT]: + return self._get_page().__await__() + + async def _get_page(self) -> AsyncPageT: + def _parser(resp: AsyncPageT) -> AsyncPageT: + resp._set_private_attributes( + model=self._model, + options=self._options, + client=self._client, + ) + return resp + + self._options.post_parser = _parser + + return await self._client.request(self._page_cls, self._options) + + async def __aiter__(self) -> AsyncIterator[_T]: + # https://github.com/microsoft/pyright/issues/3464 + page = cast( + AsyncPageT, + await self, # type: ignore + ) + async for item in page: + yield item + + +class BaseAsyncPage(BasePage[_T], Generic[_T]): + _client: AsyncAPIClient = pydantic.PrivateAttr() + + def _set_private_attributes( + self, + model: Type[_T], + client: AsyncAPIClient, + options: FinalRequestOptions, + ) -> None: + if PYDANTIC_V2 and getattr(self, "__pydantic_private__", None) is None: + self.__pydantic_private__ = {} + + self._model = model + self._client = client + self._options = options + + async def __aiter__(self) -> AsyncIterator[_T]: + async for page in self.iter_pages(): + for item in page._get_page_items(): + yield item + + async def iter_pages(self: AsyncPageT) -> AsyncIterator[AsyncPageT]: + page = self + while True: + yield page + if page.has_next_page(): + page = await page.get_next_page() + else: + return + + async def get_next_page(self: AsyncPageT) -> AsyncPageT: + info = self.next_page_info() + if not info: + raise RuntimeError( + "No next page expected; please check `.has_next_page()` before calling `.get_next_page()`." + ) + + options = self._info_to_options(info) + return await self._client._request_api_list(self._model, page=self.__class__, options=options) + + +_HttpxClientT = TypeVar("_HttpxClientT", bound=Union[httpx.Client, httpx.AsyncClient]) +_DefaultStreamT = TypeVar("_DefaultStreamT", bound=Union[Stream[Any], AsyncStream[Any]]) + + +class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]): + _client: _HttpxClientT + _version: str + _base_url: URL + max_retries: int + timeout: Union[float, Timeout, None] + _strict_response_validation: bool + _idempotency_header: str | None + _default_stream_cls: type[_DefaultStreamT] | None = None + + def __init__( + self, + *, + version: str, + base_url: str | URL, + _strict_response_validation: bool, + max_retries: int = DEFAULT_MAX_RETRIES, + timeout: float | Timeout | None = DEFAULT_TIMEOUT, + custom_headers: Mapping[str, str] | None = None, + custom_query: Mapping[str, object] | None = None, + ) -> None: + self._version = version + self._base_url = self._enforce_trailing_slash(URL(base_url)) + self.max_retries = max_retries + self.timeout = timeout + self._custom_headers = custom_headers or {} + self._custom_query = custom_query or {} + self._strict_response_validation = _strict_response_validation + self._idempotency_header = None + self._platform: Platform | None = None + + if max_retries is None: # pyright: ignore[reportUnnecessaryComparison] + raise TypeError( + "max_retries cannot be None. If you want to disable retries, pass `0`; if you want unlimited retries, pass `math.inf` or a very high number; if you want the default behavior, pass `agentex_sdk.DEFAULT_MAX_RETRIES`" + ) + + def _enforce_trailing_slash(self, url: URL) -> URL: + if url.raw_path.endswith(b"/"): + return url + return url.copy_with(raw_path=url.raw_path + b"/") + + def _make_status_error_from_response( + self, + response: httpx.Response, + ) -> APIStatusError: + if response.is_closed and not response.is_stream_consumed: + # We can't read the response body as it has been closed + # before it was read. This can happen if an event hook + # raises a status error. + body = None + err_msg = f"Error code: {response.status_code}" + else: + err_text = response.text.strip() + body = err_text + + try: + body = json.loads(err_text) + err_msg = f"Error code: {response.status_code} - {body}" + except Exception: + err_msg = err_text or f"Error code: {response.status_code}" + + return self._make_status_error(err_msg, body=body, response=response) + + def _make_status_error( + self, + err_msg: str, + *, + body: object, + response: httpx.Response, + ) -> _exceptions.APIStatusError: + raise NotImplementedError() + + def _build_headers(self, options: FinalRequestOptions, *, retries_taken: int = 0) -> httpx.Headers: + custom_headers = options.headers or {} + headers_dict = _merge_mappings(self.default_headers, custom_headers) + self._validate_headers(headers_dict, custom_headers) + + # headers are case-insensitive while dictionaries are not. + headers = httpx.Headers(headers_dict) + + idempotency_header = self._idempotency_header + if idempotency_header and options.idempotency_key and idempotency_header not in headers: + headers[idempotency_header] = options.idempotency_key + + # Don't set these headers if they were already set or removed by the caller. We check + # `custom_headers`, which can contain `Omit()`, instead of `headers` to account for the removal case. + lower_custom_headers = [header.lower() for header in custom_headers] + if "x-stainless-retry-count" not in lower_custom_headers: + headers["x-stainless-retry-count"] = str(retries_taken) + if "x-stainless-read-timeout" not in lower_custom_headers: + timeout = self.timeout if isinstance(options.timeout, NotGiven) else options.timeout + if isinstance(timeout, Timeout): + timeout = timeout.read + if timeout is not None: + headers["x-stainless-read-timeout"] = str(timeout) + + return headers + + def _prepare_url(self, url: str) -> URL: + """ + Merge a URL argument together with any 'base_url' on the client, + to create the URL used for the outgoing request. + """ + # Copied from httpx's `_merge_url` method. + merge_url = URL(url) + if merge_url.is_relative_url: + merge_raw_path = self.base_url.raw_path + merge_url.raw_path.lstrip(b"/") + return self.base_url.copy_with(raw_path=merge_raw_path) + + return merge_url + + def _make_sse_decoder(self) -> SSEDecoder | SSEBytesDecoder: + return SSEDecoder() + + def _build_request( + self, + options: FinalRequestOptions, + *, + retries_taken: int = 0, + ) -> httpx.Request: + if log.isEnabledFor(logging.DEBUG): + log.debug("Request options: %s", model_dump(options, exclude_unset=True)) + + kwargs: dict[str, Any] = {} + + json_data = options.json_data + if options.extra_json is not None: + if json_data is None: + json_data = cast(Body, options.extra_json) + elif is_mapping(json_data): + json_data = _merge_mappings(json_data, options.extra_json) + else: + raise RuntimeError(f"Unexpected JSON data type, {type(json_data)}, cannot merge with `extra_body`") + + headers = self._build_headers(options, retries_taken=retries_taken) + params = _merge_mappings(self.default_query, options.params) + content_type = headers.get("Content-Type") + files = options.files + + # If the given Content-Type header is multipart/form-data then it + # has to be removed so that httpx can generate the header with + # additional information for us as it has to be in this form + # for the server to be able to correctly parse the request: + # multipart/form-data; boundary=---abc-- + if content_type is not None and content_type.startswith("multipart/form-data"): + if "boundary" not in content_type: + # only remove the header if the boundary hasn't been explicitly set + # as the caller doesn't want httpx to come up with their own boundary + headers.pop("Content-Type") + + # As we are now sending multipart/form-data instead of application/json + # we need to tell httpx to use it, https://www.python-httpx.org/advanced/clients/#multipart-file-encoding + if json_data: + if not is_dict(json_data): + raise TypeError( + f"Expected query input to be a dictionary for multipart requests but got {type(json_data)} instead." + ) + kwargs["data"] = self._serialize_multipartform(json_data) + + # httpx determines whether or not to send a "multipart/form-data" + # request based on the truthiness of the "files" argument. + # This gets around that issue by generating a dict value that + # evaluates to true. + # + # https://github.com/encode/httpx/discussions/2399#discussioncomment-3814186 + if not files: + files = cast(HttpxRequestFiles, ForceMultipartDict()) + + prepared_url = self._prepare_url(options.url) + if "_" in prepared_url.host: + # work around https://github.com/encode/httpx/discussions/2880 + kwargs["extensions"] = {"sni_hostname": prepared_url.host.replace("_", "-")} + + is_body_allowed = options.method.lower() != "get" + + if is_body_allowed: + kwargs["json"] = json_data if is_given(json_data) else None + kwargs["files"] = files + else: + headers.pop("Content-Type", None) + kwargs.pop("data", None) + + # TODO: report this error to httpx + return self._client.build_request( # pyright: ignore[reportUnknownMemberType] + headers=headers, + timeout=self.timeout if isinstance(options.timeout, NotGiven) else options.timeout, + method=options.method, + url=prepared_url, + # the `Query` type that we use is incompatible with qs' + # `Params` type as it needs to be typed as `Mapping[str, object]` + # so that passing a `TypedDict` doesn't cause an error. + # https://github.com/microsoft/pyright/issues/3526#event-6715453066 + params=self.qs.stringify(cast(Mapping[str, Any], params)) if params else None, + **kwargs, + ) + + def _serialize_multipartform(self, data: Mapping[object, object]) -> dict[str, object]: + items = self.qs.stringify_items( + # TODO: type ignore is required as stringify_items is well typed but we can't be + # well typed without heavy validation. + data, # type: ignore + array_format="brackets", + ) + serialized: dict[str, object] = {} + for key, value in items: + existing = serialized.get(key) + + if not existing: + serialized[key] = value + continue + + # If a value has already been set for this key then that + # means we're sending data like `array[]=[1, 2, 3]` and we + # need to tell httpx that we want to send multiple values with + # the same key which is done by using a list or a tuple. + # + # Note: 2d arrays should never result in the same key at both + # levels so it's safe to assume that if the value is a list, + # it was because we changed it to be a list. + if is_list(existing): + existing.append(value) + else: + serialized[key] = [existing, value] + + return serialized + + def _maybe_override_cast_to(self, cast_to: type[ResponseT], options: FinalRequestOptions) -> type[ResponseT]: + if not is_given(options.headers): + return cast_to + + # make a copy of the headers so we don't mutate user-input + headers = dict(options.headers) + + # we internally support defining a temporary header to override the + # default `cast_to` type for use with `.with_raw_response` and `.with_streaming_response` + # see _response.py for implementation details + override_cast_to = headers.pop(OVERRIDE_CAST_TO_HEADER, NOT_GIVEN) + if is_given(override_cast_to): + options.headers = headers + return cast(Type[ResponseT], override_cast_to) + + return cast_to + + def _should_stream_response_body(self, request: httpx.Request) -> bool: + return request.headers.get(RAW_RESPONSE_HEADER) == "stream" # type: ignore[no-any-return] + + def _process_response_data( + self, + *, + data: object, + cast_to: type[ResponseT], + response: httpx.Response, + ) -> ResponseT: + if data is None: + return cast(ResponseT, None) + + if cast_to is object: + return cast(ResponseT, data) + + try: + if inspect.isclass(cast_to) and issubclass(cast_to, ModelBuilderProtocol): + return cast(ResponseT, cast_to.build(response=response, data=data)) + + if self._strict_response_validation: + return cast(ResponseT, validate_type(type_=cast_to, value=data)) + + return cast(ResponseT, construct_type(type_=cast_to, value=data)) + except pydantic.ValidationError as err: + raise APIResponseValidationError(response=response, body=data) from err + + @property + def qs(self) -> Querystring: + return Querystring() + + @property + def custom_auth(self) -> httpx.Auth | None: + return None + + @property + def auth_headers(self) -> dict[str, str]: + return {} + + @property + def default_headers(self) -> dict[str, str | Omit]: + return { + "Accept": "application/json", + "Content-Type": "application/json", + "User-Agent": self.user_agent, + **self.platform_headers(), + **self.auth_headers, + **self._custom_headers, + } + + @property + def default_query(self) -> dict[str, object]: + return { + **self._custom_query, + } + + def _validate_headers( + self, + headers: Headers, # noqa: ARG002 + custom_headers: Headers, # noqa: ARG002 + ) -> None: + """Validate the given default headers and custom headers. + + Does nothing by default. + """ + return + + @property + def user_agent(self) -> str: + return f"{self.__class__.__name__}/Python {self._version}" + + @property + def base_url(self) -> URL: + return self._base_url + + @base_url.setter + def base_url(self, url: URL | str) -> None: + self._base_url = self._enforce_trailing_slash(url if isinstance(url, URL) else URL(url)) + + def platform_headers(self) -> Dict[str, str]: + # the actual implementation is in a separate `lru_cache` decorated + # function because adding `lru_cache` to methods will leak memory + # https://github.com/python/cpython/issues/88476 + return platform_headers(self._version, platform=self._platform) + + def _parse_retry_after_header(self, response_headers: Optional[httpx.Headers] = None) -> float | None: + """Returns a float of the number of seconds (not milliseconds) to wait after retrying, or None if unspecified. + + About the Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After + See also https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After#syntax + """ + if response_headers is None: + return None + + # First, try the non-standard `retry-after-ms` header for milliseconds, + # which is more precise than integer-seconds `retry-after` + try: + retry_ms_header = response_headers.get("retry-after-ms", None) + return float(retry_ms_header) / 1000 + except (TypeError, ValueError): + pass + + # Next, try parsing `retry-after` header as seconds (allowing nonstandard floats). + retry_header = response_headers.get("retry-after") + try: + # note: the spec indicates that this should only ever be an integer + # but if someone sends a float there's no reason for us to not respect it + return float(retry_header) + except (TypeError, ValueError): + pass + + # Last, try parsing `retry-after` as a date. + retry_date_tuple = email.utils.parsedate_tz(retry_header) + if retry_date_tuple is None: + return None + + retry_date = email.utils.mktime_tz(retry_date_tuple) + return float(retry_date - time.time()) + + def _calculate_retry_timeout( + self, + remaining_retries: int, + options: FinalRequestOptions, + response_headers: Optional[httpx.Headers] = None, + ) -> float: + max_retries = options.get_max_retries(self.max_retries) + + # If the API asks us to wait a certain amount of time (and it's a reasonable amount), just do what it says. + retry_after = self._parse_retry_after_header(response_headers) + if retry_after is not None and 0 < retry_after <= 60: + return retry_after + + # Also cap retry count to 1000 to avoid any potential overflows with `pow` + nb_retries = min(max_retries - remaining_retries, 1000) + + # Apply exponential backoff, but not more than the max. + sleep_seconds = min(INITIAL_RETRY_DELAY * pow(2.0, nb_retries), MAX_RETRY_DELAY) + + # Apply some jitter, plus-or-minus half a second. + jitter = 1 - 0.25 * random() + timeout = sleep_seconds * jitter + return timeout if timeout >= 0 else 0 + + def _should_retry(self, response: httpx.Response) -> bool: + # Note: this is not a standard header + should_retry_header = response.headers.get("x-should-retry") + + # If the server explicitly says whether or not to retry, obey. + if should_retry_header == "true": + log.debug("Retrying as header `x-should-retry` is set to `true`") + return True + if should_retry_header == "false": + log.debug("Not retrying as header `x-should-retry` is set to `false`") + return False + + # Retry on request timeouts. + if response.status_code == 408: + log.debug("Retrying due to status code %i", response.status_code) + return True + + # Retry on lock timeouts. + if response.status_code == 409: + log.debug("Retrying due to status code %i", response.status_code) + return True + + # Retry on rate limits. + if response.status_code == 429: + log.debug("Retrying due to status code %i", response.status_code) + return True + + # Retry internal errors. + if response.status_code >= 500: + log.debug("Retrying due to status code %i", response.status_code) + return True + + log.debug("Not retrying") + return False + + def _idempotency_key(self) -> str: + return f"stainless-python-retry-{uuid.uuid4()}" + + +class _DefaultHttpxClient(httpx.Client): + def __init__(self, **kwargs: Any) -> None: + kwargs.setdefault("timeout", DEFAULT_TIMEOUT) + kwargs.setdefault("limits", DEFAULT_CONNECTION_LIMITS) + kwargs.setdefault("follow_redirects", True) + super().__init__(**kwargs) + + +if TYPE_CHECKING: + DefaultHttpxClient = httpx.Client + """An alias to `httpx.Client` that provides the same defaults that this SDK + uses internally. + + This is useful because overriding the `http_client` with your own instance of + `httpx.Client` will result in httpx's defaults being used, not ours. + """ +else: + DefaultHttpxClient = _DefaultHttpxClient + + +class SyncHttpxClientWrapper(DefaultHttpxClient): + def __del__(self) -> None: + if self.is_closed: + return + + try: + self.close() + except Exception: + pass + + +class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]): + _client: httpx.Client + _default_stream_cls: type[Stream[Any]] | None = None + + def __init__( + self, + *, + version: str, + base_url: str | URL, + max_retries: int = DEFAULT_MAX_RETRIES, + timeout: float | Timeout | None | NotGiven = NOT_GIVEN, + http_client: httpx.Client | None = None, + custom_headers: Mapping[str, str] | None = None, + custom_query: Mapping[str, object] | None = None, + _strict_response_validation: bool, + ) -> None: + if not is_given(timeout): + # if the user passed in a custom http client with a non-default + # timeout set then we use that timeout. + # + # note: there is an edge case here where the user passes in a client + # where they've explicitly set the timeout to match the default timeout + # as this check is structural, meaning that we'll think they didn't + # pass in a timeout and will ignore it + if http_client and http_client.timeout != HTTPX_DEFAULT_TIMEOUT: + timeout = http_client.timeout + else: + timeout = DEFAULT_TIMEOUT + + if http_client is not None and not isinstance(http_client, httpx.Client): # pyright: ignore[reportUnnecessaryIsInstance] + raise TypeError( + f"Invalid `http_client` argument; Expected an instance of `httpx.Client` but got {type(http_client)}" + ) + + super().__init__( + version=version, + # cast to a valid type because mypy doesn't understand our type narrowing + timeout=cast(Timeout, timeout), + base_url=base_url, + max_retries=max_retries, + custom_query=custom_query, + custom_headers=custom_headers, + _strict_response_validation=_strict_response_validation, + ) + self._client = http_client or SyncHttpxClientWrapper( + base_url=base_url, + # cast to a valid type because mypy doesn't understand our type narrowing + timeout=cast(Timeout, timeout), + ) + + def is_closed(self) -> bool: + return self._client.is_closed + + def close(self) -> None: + """Close the underlying HTTPX client. + + The client will *not* be usable after this. + """ + # If an error is thrown while constructing a client, self._client + # may not be present + if hasattr(self, "_client"): + self._client.close() + + def __enter__(self: _T) -> _T: + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.close() + + def _prepare_options( + self, + options: FinalRequestOptions, # noqa: ARG002 + ) -> FinalRequestOptions: + """Hook for mutating the given options""" + return options + + def _prepare_request( + self, + request: httpx.Request, # noqa: ARG002 + ) -> None: + """This method is used as a callback for mutating the `Request` object + after it has been constructed. + This is useful for cases where you want to add certain headers based off of + the request properties, e.g. `url`, `method` etc. + """ + return None + + @overload + def request( + self, + cast_to: Type[ResponseT], + options: FinalRequestOptions, + *, + stream: Literal[True], + stream_cls: Type[_StreamT], + ) -> _StreamT: ... + + @overload + def request( + self, + cast_to: Type[ResponseT], + options: FinalRequestOptions, + *, + stream: Literal[False] = False, + ) -> ResponseT: ... + + @overload + def request( + self, + cast_to: Type[ResponseT], + options: FinalRequestOptions, + *, + stream: bool = False, + stream_cls: Type[_StreamT] | None = None, + ) -> ResponseT | _StreamT: ... + + def request( + self, + cast_to: Type[ResponseT], + options: FinalRequestOptions, + *, + stream: bool = False, + stream_cls: type[_StreamT] | None = None, + ) -> ResponseT | _StreamT: + cast_to = self._maybe_override_cast_to(cast_to, options) + + # create a copy of the options we were given so that if the + # options are mutated later & we then retry, the retries are + # given the original options + input_options = model_copy(options) + if input_options.idempotency_key is None and input_options.method.lower() != "get": + # ensure the idempotency key is reused between requests + input_options.idempotency_key = self._idempotency_key() + + response: httpx.Response | None = None + max_retries = input_options.get_max_retries(self.max_retries) + + retries_taken = 0 + for retries_taken in range(max_retries + 1): + options = model_copy(input_options) + options = self._prepare_options(options) + + remaining_retries = max_retries - retries_taken + request = self._build_request(options, retries_taken=retries_taken) + self._prepare_request(request) + + kwargs: HttpxSendArgs = {} + if self.custom_auth is not None: + kwargs["auth"] = self.custom_auth + + if options.follow_redirects is not None: + kwargs["follow_redirects"] = options.follow_redirects + + log.debug("Sending HTTP Request: %s %s", request.method, request.url) + + response = None + try: + response = self._client.send( + request, + stream=stream or self._should_stream_response_body(request=request), + **kwargs, + ) + except httpx.TimeoutException as err: + log.debug("Encountered httpx.TimeoutException", exc_info=True) + + if remaining_retries > 0: + self._sleep_for_retry( + retries_taken=retries_taken, + max_retries=max_retries, + options=input_options, + response=None, + ) + continue + + log.debug("Raising timeout error") + raise APITimeoutError(request=request) from err + except Exception as err: + log.debug("Encountered Exception", exc_info=True) + + if remaining_retries > 0: + self._sleep_for_retry( + retries_taken=retries_taken, + max_retries=max_retries, + options=input_options, + response=None, + ) + continue + + log.debug("Raising connection error") + raise APIConnectionError(request=request) from err + + log.debug( + 'HTTP Response: %s %s "%i %s" %s', + request.method, + request.url, + response.status_code, + response.reason_phrase, + response.headers, + ) + + try: + response.raise_for_status() + except httpx.HTTPStatusError as err: # thrown on 4xx and 5xx status code + log.debug("Encountered httpx.HTTPStatusError", exc_info=True) + + if remaining_retries > 0 and self._should_retry(err.response): + err.response.close() + self._sleep_for_retry( + retries_taken=retries_taken, + max_retries=max_retries, + options=input_options, + response=response, + ) + continue + + # If the response is streamed then we need to explicitly read the response + # to completion before attempting to access the response text. + if not err.response.is_closed: + err.response.read() + + log.debug("Re-raising status error") + raise self._make_status_error_from_response(err.response) from None + + break + + assert response is not None, "could not resolve response (should never happen)" + return self._process_response( + cast_to=cast_to, + options=options, + response=response, + stream=stream, + stream_cls=stream_cls, + retries_taken=retries_taken, + ) + + def _sleep_for_retry( + self, *, retries_taken: int, max_retries: int, options: FinalRequestOptions, response: httpx.Response | None + ) -> None: + remaining_retries = max_retries - retries_taken + if remaining_retries == 1: + log.debug("1 retry left") + else: + log.debug("%i retries left", remaining_retries) + + timeout = self._calculate_retry_timeout(remaining_retries, options, response.headers if response else None) + log.info("Retrying request to %s in %f seconds", options.url, timeout) + + time.sleep(timeout) + + def _process_response( + self, + *, + cast_to: Type[ResponseT], + options: FinalRequestOptions, + response: httpx.Response, + stream: bool, + stream_cls: type[Stream[Any]] | type[AsyncStream[Any]] | None, + retries_taken: int = 0, + ) -> ResponseT: + origin = get_origin(cast_to) or cast_to + + if ( + inspect.isclass(origin) + and issubclass(origin, BaseAPIResponse) + # we only want to actually return the custom BaseAPIResponse class if we're + # returning the raw response, or if we're not streaming SSE, as if we're streaming + # SSE then `cast_to` doesn't actively reflect the type we need to parse into + and (not stream or bool(response.request.headers.get(RAW_RESPONSE_HEADER))) + ): + if not issubclass(origin, APIResponse): + raise TypeError(f"API Response types must subclass {APIResponse}; Received {origin}") + + response_cls = cast("type[BaseAPIResponse[Any]]", cast_to) + return cast( + ResponseT, + response_cls( + raw=response, + client=self, + cast_to=extract_response_type(response_cls), + stream=stream, + stream_cls=stream_cls, + options=options, + retries_taken=retries_taken, + ), + ) + + if cast_to == httpx.Response: + return cast(ResponseT, response) + + api_response = APIResponse( + raw=response, + client=self, + cast_to=cast("type[ResponseT]", cast_to), # pyright: ignore[reportUnnecessaryCast] + stream=stream, + stream_cls=stream_cls, + options=options, + retries_taken=retries_taken, + ) + if bool(response.request.headers.get(RAW_RESPONSE_HEADER)): + return cast(ResponseT, api_response) + + return api_response.parse() + + def _request_api_list( + self, + model: Type[object], + page: Type[SyncPageT], + options: FinalRequestOptions, + ) -> SyncPageT: + def _parser(resp: SyncPageT) -> SyncPageT: + resp._set_private_attributes( + client=self, + model=model, + options=options, + ) + return resp + + options.post_parser = _parser + + return self.request(page, options, stream=False) + + @overload + def get( + self, + path: str, + *, + cast_to: Type[ResponseT], + options: RequestOptions = {}, + stream: Literal[False] = False, + ) -> ResponseT: ... + + @overload + def get( + self, + path: str, + *, + cast_to: Type[ResponseT], + options: RequestOptions = {}, + stream: Literal[True], + stream_cls: type[_StreamT], + ) -> _StreamT: ... + + @overload + def get( + self, + path: str, + *, + cast_to: Type[ResponseT], + options: RequestOptions = {}, + stream: bool, + stream_cls: type[_StreamT] | None = None, + ) -> ResponseT | _StreamT: ... + + def get( + self, + path: str, + *, + cast_to: Type[ResponseT], + options: RequestOptions = {}, + stream: bool = False, + stream_cls: type[_StreamT] | None = None, + ) -> ResponseT | _StreamT: + opts = FinalRequestOptions.construct(method="get", url=path, **options) + # cast is required because mypy complains about returning Any even though + # it understands the type variables + return cast(ResponseT, self.request(cast_to, opts, stream=stream, stream_cls=stream_cls)) + + @overload + def post( + self, + path: str, + *, + cast_to: Type[ResponseT], + body: Body | None = None, + options: RequestOptions = {}, + files: RequestFiles | None = None, + stream: Literal[False] = False, + ) -> ResponseT: ... + + @overload + def post( + self, + path: str, + *, + cast_to: Type[ResponseT], + body: Body | None = None, + options: RequestOptions = {}, + files: RequestFiles | None = None, + stream: Literal[True], + stream_cls: type[_StreamT], + ) -> _StreamT: ... + + @overload + def post( + self, + path: str, + *, + cast_to: Type[ResponseT], + body: Body | None = None, + options: RequestOptions = {}, + files: RequestFiles | None = None, + stream: bool, + stream_cls: type[_StreamT] | None = None, + ) -> ResponseT | _StreamT: ... + + def post( + self, + path: str, + *, + cast_to: Type[ResponseT], + body: Body | None = None, + options: RequestOptions = {}, + files: RequestFiles | None = None, + stream: bool = False, + stream_cls: type[_StreamT] | None = None, + ) -> ResponseT | _StreamT: + opts = FinalRequestOptions.construct( + method="post", url=path, json_data=body, files=to_httpx_files(files), **options + ) + return cast(ResponseT, self.request(cast_to, opts, stream=stream, stream_cls=stream_cls)) + + def patch( + self, + path: str, + *, + cast_to: Type[ResponseT], + body: Body | None = None, + options: RequestOptions = {}, + ) -> ResponseT: + opts = FinalRequestOptions.construct(method="patch", url=path, json_data=body, **options) + return self.request(cast_to, opts) + + def put( + self, + path: str, + *, + cast_to: Type[ResponseT], + body: Body | None = None, + files: RequestFiles | None = None, + options: RequestOptions = {}, + ) -> ResponseT: + opts = FinalRequestOptions.construct( + method="put", url=path, json_data=body, files=to_httpx_files(files), **options + ) + return self.request(cast_to, opts) + + def delete( + self, + path: str, + *, + cast_to: Type[ResponseT], + body: Body | None = None, + options: RequestOptions = {}, + ) -> ResponseT: + opts = FinalRequestOptions.construct(method="delete", url=path, json_data=body, **options) + return self.request(cast_to, opts) + + def get_api_list( + self, + path: str, + *, + model: Type[object], + page: Type[SyncPageT], + body: Body | None = None, + options: RequestOptions = {}, + method: str = "get", + ) -> SyncPageT: + opts = FinalRequestOptions.construct(method=method, url=path, json_data=body, **options) + return self._request_api_list(model, page, opts) + + +class _DefaultAsyncHttpxClient(httpx.AsyncClient): + def __init__(self, **kwargs: Any) -> None: + kwargs.setdefault("timeout", DEFAULT_TIMEOUT) + kwargs.setdefault("limits", DEFAULT_CONNECTION_LIMITS) + kwargs.setdefault("follow_redirects", True) + super().__init__(**kwargs) + + +try: + import httpx_aiohttp +except ImportError: + + class _DefaultAioHttpClient(httpx.AsyncClient): + def __init__(self, **_kwargs: Any) -> None: + raise RuntimeError("To use the aiohttp client you must have installed the package with the `aiohttp` extra") +else: + + class _DefaultAioHttpClient(httpx_aiohttp.HttpxAiohttpClient): # type: ignore + def __init__(self, **kwargs: Any) -> None: + kwargs.setdefault("timeout", DEFAULT_TIMEOUT) + kwargs.setdefault("limits", DEFAULT_CONNECTION_LIMITS) + kwargs.setdefault("follow_redirects", True) + + super().__init__(**kwargs) + + +if TYPE_CHECKING: + DefaultAsyncHttpxClient = httpx.AsyncClient + """An alias to `httpx.AsyncClient` that provides the same defaults that this SDK + uses internally. + + This is useful because overriding the `http_client` with your own instance of + `httpx.AsyncClient` will result in httpx's defaults being used, not ours. + """ + + DefaultAioHttpClient = httpx.AsyncClient + """An alias to `httpx.AsyncClient` that changes the default HTTP transport to `aiohttp`.""" +else: + DefaultAsyncHttpxClient = _DefaultAsyncHttpxClient + DefaultAioHttpClient = _DefaultAioHttpClient + + +class AsyncHttpxClientWrapper(DefaultAsyncHttpxClient): + def __del__(self) -> None: + if self.is_closed: + return + + try: + # TODO(someday): support non asyncio runtimes here + asyncio.get_running_loop().create_task(self.aclose()) + except Exception: + pass + + +class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]): + _client: httpx.AsyncClient + _default_stream_cls: type[AsyncStream[Any]] | None = None + + def __init__( + self, + *, + version: str, + base_url: str | URL, + _strict_response_validation: bool, + max_retries: int = DEFAULT_MAX_RETRIES, + timeout: float | Timeout | None | NotGiven = NOT_GIVEN, + http_client: httpx.AsyncClient | None = None, + custom_headers: Mapping[str, str] | None = None, + custom_query: Mapping[str, object] | None = None, + ) -> None: + if not is_given(timeout): + # if the user passed in a custom http client with a non-default + # timeout set then we use that timeout. + # + # note: there is an edge case here where the user passes in a client + # where they've explicitly set the timeout to match the default timeout + # as this check is structural, meaning that we'll think they didn't + # pass in a timeout and will ignore it + if http_client and http_client.timeout != HTTPX_DEFAULT_TIMEOUT: + timeout = http_client.timeout + else: + timeout = DEFAULT_TIMEOUT + + if http_client is not None and not isinstance(http_client, httpx.AsyncClient): # pyright: ignore[reportUnnecessaryIsInstance] + raise TypeError( + f"Invalid `http_client` argument; Expected an instance of `httpx.AsyncClient` but got {type(http_client)}" + ) + + super().__init__( + version=version, + base_url=base_url, + # cast to a valid type because mypy doesn't understand our type narrowing + timeout=cast(Timeout, timeout), + max_retries=max_retries, + custom_query=custom_query, + custom_headers=custom_headers, + _strict_response_validation=_strict_response_validation, + ) + self._client = http_client or AsyncHttpxClientWrapper( + base_url=base_url, + # cast to a valid type because mypy doesn't understand our type narrowing + timeout=cast(Timeout, timeout), + ) + + def is_closed(self) -> bool: + return self._client.is_closed + + async def close(self) -> None: + """Close the underlying HTTPX client. + + The client will *not* be usable after this. + """ + await self._client.aclose() + + async def __aenter__(self: _T) -> _T: + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + await self.close() + + async def _prepare_options( + self, + options: FinalRequestOptions, # noqa: ARG002 + ) -> FinalRequestOptions: + """Hook for mutating the given options""" + return options + + async def _prepare_request( + self, + request: httpx.Request, # noqa: ARG002 + ) -> None: + """This method is used as a callback for mutating the `Request` object + after it has been constructed. + This is useful for cases where you want to add certain headers based off of + the request properties, e.g. `url`, `method` etc. + """ + return None + + @overload + async def request( + self, + cast_to: Type[ResponseT], + options: FinalRequestOptions, + *, + stream: Literal[False] = False, + ) -> ResponseT: ... + + @overload + async def request( + self, + cast_to: Type[ResponseT], + options: FinalRequestOptions, + *, + stream: Literal[True], + stream_cls: type[_AsyncStreamT], + ) -> _AsyncStreamT: ... + + @overload + async def request( + self, + cast_to: Type[ResponseT], + options: FinalRequestOptions, + *, + stream: bool, + stream_cls: type[_AsyncStreamT] | None = None, + ) -> ResponseT | _AsyncStreamT: ... + + async def request( + self, + cast_to: Type[ResponseT], + options: FinalRequestOptions, + *, + stream: bool = False, + stream_cls: type[_AsyncStreamT] | None = None, + ) -> ResponseT | _AsyncStreamT: + if self._platform is None: + # `get_platform` can make blocking IO calls so we + # execute it earlier while we are in an async context + self._platform = await asyncify(get_platform)() + + cast_to = self._maybe_override_cast_to(cast_to, options) + + # create a copy of the options we were given so that if the + # options are mutated later & we then retry, the retries are + # given the original options + input_options = model_copy(options) + if input_options.idempotency_key is None and input_options.method.lower() != "get": + # ensure the idempotency key is reused between requests + input_options.idempotency_key = self._idempotency_key() + + response: httpx.Response | None = None + max_retries = input_options.get_max_retries(self.max_retries) + + retries_taken = 0 + for retries_taken in range(max_retries + 1): + options = model_copy(input_options) + options = await self._prepare_options(options) + + remaining_retries = max_retries - retries_taken + request = self._build_request(options, retries_taken=retries_taken) + await self._prepare_request(request) + + kwargs: HttpxSendArgs = {} + if self.custom_auth is not None: + kwargs["auth"] = self.custom_auth + + if options.follow_redirects is not None: + kwargs["follow_redirects"] = options.follow_redirects + + log.debug("Sending HTTP Request: %s %s", request.method, request.url) + + response = None + try: + response = await self._client.send( + request, + stream=stream or self._should_stream_response_body(request=request), + **kwargs, + ) + except httpx.TimeoutException as err: + log.debug("Encountered httpx.TimeoutException", exc_info=True) + + if remaining_retries > 0: + await self._sleep_for_retry( + retries_taken=retries_taken, + max_retries=max_retries, + options=input_options, + response=None, + ) + continue + + log.debug("Raising timeout error") + raise APITimeoutError(request=request) from err + except Exception as err: + log.debug("Encountered Exception", exc_info=True) + + if remaining_retries > 0: + await self._sleep_for_retry( + retries_taken=retries_taken, + max_retries=max_retries, + options=input_options, + response=None, + ) + continue + + log.debug("Raising connection error") + raise APIConnectionError(request=request) from err + + log.debug( + 'HTTP Response: %s %s "%i %s" %s', + request.method, + request.url, + response.status_code, + response.reason_phrase, + response.headers, + ) + + try: + response.raise_for_status() + except httpx.HTTPStatusError as err: # thrown on 4xx and 5xx status code + log.debug("Encountered httpx.HTTPStatusError", exc_info=True) + + if remaining_retries > 0 and self._should_retry(err.response): + await err.response.aclose() + await self._sleep_for_retry( + retries_taken=retries_taken, + max_retries=max_retries, + options=input_options, + response=response, + ) + continue + + # If the response is streamed then we need to explicitly read the response + # to completion before attempting to access the response text. + if not err.response.is_closed: + await err.response.aread() + + log.debug("Re-raising status error") + raise self._make_status_error_from_response(err.response) from None + + break + + assert response is not None, "could not resolve response (should never happen)" + return await self._process_response( + cast_to=cast_to, + options=options, + response=response, + stream=stream, + stream_cls=stream_cls, + retries_taken=retries_taken, + ) + + async def _sleep_for_retry( + self, *, retries_taken: int, max_retries: int, options: FinalRequestOptions, response: httpx.Response | None + ) -> None: + remaining_retries = max_retries - retries_taken + if remaining_retries == 1: + log.debug("1 retry left") + else: + log.debug("%i retries left", remaining_retries) + + timeout = self._calculate_retry_timeout(remaining_retries, options, response.headers if response else None) + log.info("Retrying request to %s in %f seconds", options.url, timeout) + + await anyio.sleep(timeout) + + async def _process_response( + self, + *, + cast_to: Type[ResponseT], + options: FinalRequestOptions, + response: httpx.Response, + stream: bool, + stream_cls: type[Stream[Any]] | type[AsyncStream[Any]] | None, + retries_taken: int = 0, + ) -> ResponseT: + origin = get_origin(cast_to) or cast_to + + if ( + inspect.isclass(origin) + and issubclass(origin, BaseAPIResponse) + # we only want to actually return the custom BaseAPIResponse class if we're + # returning the raw response, or if we're not streaming SSE, as if we're streaming + # SSE then `cast_to` doesn't actively reflect the type we need to parse into + and (not stream or bool(response.request.headers.get(RAW_RESPONSE_HEADER))) + ): + if not issubclass(origin, AsyncAPIResponse): + raise TypeError(f"API Response types must subclass {AsyncAPIResponse}; Received {origin}") + + response_cls = cast("type[BaseAPIResponse[Any]]", cast_to) + return cast( + "ResponseT", + response_cls( + raw=response, + client=self, + cast_to=extract_response_type(response_cls), + stream=stream, + stream_cls=stream_cls, + options=options, + retries_taken=retries_taken, + ), + ) + + if cast_to == httpx.Response: + return cast(ResponseT, response) + + api_response = AsyncAPIResponse( + raw=response, + client=self, + cast_to=cast("type[ResponseT]", cast_to), # pyright: ignore[reportUnnecessaryCast] + stream=stream, + stream_cls=stream_cls, + options=options, + retries_taken=retries_taken, + ) + if bool(response.request.headers.get(RAW_RESPONSE_HEADER)): + return cast(ResponseT, api_response) + + return await api_response.parse() + + def _request_api_list( + self, + model: Type[_T], + page: Type[AsyncPageT], + options: FinalRequestOptions, + ) -> AsyncPaginator[_T, AsyncPageT]: + return AsyncPaginator(client=self, options=options, page_cls=page, model=model) + + @overload + async def get( + self, + path: str, + *, + cast_to: Type[ResponseT], + options: RequestOptions = {}, + stream: Literal[False] = False, + ) -> ResponseT: ... + + @overload + async def get( + self, + path: str, + *, + cast_to: Type[ResponseT], + options: RequestOptions = {}, + stream: Literal[True], + stream_cls: type[_AsyncStreamT], + ) -> _AsyncStreamT: ... + + @overload + async def get( + self, + path: str, + *, + cast_to: Type[ResponseT], + options: RequestOptions = {}, + stream: bool, + stream_cls: type[_AsyncStreamT] | None = None, + ) -> ResponseT | _AsyncStreamT: ... + + async def get( + self, + path: str, + *, + cast_to: Type[ResponseT], + options: RequestOptions = {}, + stream: bool = False, + stream_cls: type[_AsyncStreamT] | None = None, + ) -> ResponseT | _AsyncStreamT: + opts = FinalRequestOptions.construct(method="get", url=path, **options) + return await self.request(cast_to, opts, stream=stream, stream_cls=stream_cls) + + @overload + async def post( + self, + path: str, + *, + cast_to: Type[ResponseT], + body: Body | None = None, + files: RequestFiles | None = None, + options: RequestOptions = {}, + stream: Literal[False] = False, + ) -> ResponseT: ... + + @overload + async def post( + self, + path: str, + *, + cast_to: Type[ResponseT], + body: Body | None = None, + files: RequestFiles | None = None, + options: RequestOptions = {}, + stream: Literal[True], + stream_cls: type[_AsyncStreamT], + ) -> _AsyncStreamT: ... + + @overload + async def post( + self, + path: str, + *, + cast_to: Type[ResponseT], + body: Body | None = None, + files: RequestFiles | None = None, + options: RequestOptions = {}, + stream: bool, + stream_cls: type[_AsyncStreamT] | None = None, + ) -> ResponseT | _AsyncStreamT: ... + + async def post( + self, + path: str, + *, + cast_to: Type[ResponseT], + body: Body | None = None, + files: RequestFiles | None = None, + options: RequestOptions = {}, + stream: bool = False, + stream_cls: type[_AsyncStreamT] | None = None, + ) -> ResponseT | _AsyncStreamT: + opts = FinalRequestOptions.construct( + method="post", url=path, json_data=body, files=await async_to_httpx_files(files), **options + ) + return await self.request(cast_to, opts, stream=stream, stream_cls=stream_cls) + + async def patch( + self, + path: str, + *, + cast_to: Type[ResponseT], + body: Body | None = None, + options: RequestOptions = {}, + ) -> ResponseT: + opts = FinalRequestOptions.construct(method="patch", url=path, json_data=body, **options) + return await self.request(cast_to, opts) + + async def put( + self, + path: str, + *, + cast_to: Type[ResponseT], + body: Body | None = None, + files: RequestFiles | None = None, + options: RequestOptions = {}, + ) -> ResponseT: + opts = FinalRequestOptions.construct( + method="put", url=path, json_data=body, files=await async_to_httpx_files(files), **options + ) + return await self.request(cast_to, opts) + + async def delete( + self, + path: str, + *, + cast_to: Type[ResponseT], + body: Body | None = None, + options: RequestOptions = {}, + ) -> ResponseT: + opts = FinalRequestOptions.construct(method="delete", url=path, json_data=body, **options) + return await self.request(cast_to, opts) + + def get_api_list( + self, + path: str, + *, + model: Type[_T], + page: Type[AsyncPageT], + body: Body | None = None, + options: RequestOptions = {}, + method: str = "get", + ) -> AsyncPaginator[_T, AsyncPageT]: + opts = FinalRequestOptions.construct(method=method, url=path, json_data=body, **options) + return self._request_api_list(model, page, opts) + + +def make_request_options( + *, + query: Query | None = None, + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + idempotency_key: str | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + post_parser: PostParser | NotGiven = NOT_GIVEN, +) -> RequestOptions: + """Create a dict of type RequestOptions without keys of NotGiven values.""" + options: RequestOptions = {} + if extra_headers is not None: + options["headers"] = extra_headers + + if extra_body is not None: + options["extra_json"] = cast(AnyMapping, extra_body) + + if query is not None: + options["params"] = query + + if extra_query is not None: + options["params"] = {**options.get("params", {}), **extra_query} + + if not isinstance(timeout, NotGiven): + options["timeout"] = timeout + + if idempotency_key is not None: + options["idempotency_key"] = idempotency_key + + if is_given(post_parser): + # internal + options["post_parser"] = post_parser # type: ignore + + return options + + +class ForceMultipartDict(Dict[str, None]): + def __bool__(self) -> bool: + return True + + +class OtherPlatform: + def __init__(self, name: str) -> None: + self.name = name + + @override + def __str__(self) -> str: + return f"Other:{self.name}" + + +Platform = Union[ + OtherPlatform, + Literal[ + "MacOS", + "Linux", + "Windows", + "FreeBSD", + "OpenBSD", + "iOS", + "Android", + "Unknown", + ], +] + + +def get_platform() -> Platform: + try: + system = platform.system().lower() + platform_name = platform.platform().lower() + except Exception: + return "Unknown" + + if "iphone" in platform_name or "ipad" in platform_name: + # Tested using Python3IDE on an iPhone 11 and Pythonista on an iPad 7 + # system is Darwin and platform_name is a string like: + # - Darwin-21.6.0-iPhone12,1-64bit + # - Darwin-21.6.0-iPad7,11-64bit + return "iOS" + + if system == "darwin": + return "MacOS" + + if system == "windows": + return "Windows" + + if "android" in platform_name: + # Tested using Pydroid 3 + # system is Linux and platform_name is a string like 'Linux-5.10.81-android12-9-00001-geba40aecb3b7-ab8534902-aarch64-with-libc' + return "Android" + + if system == "linux": + # https://distro.readthedocs.io/en/latest/#distro.id + distro_id = distro.id() + if distro_id == "freebsd": + return "FreeBSD" + + if distro_id == "openbsd": + return "OpenBSD" + + return "Linux" + + if platform_name: + return OtherPlatform(platform_name) + + return "Unknown" + + +@lru_cache(maxsize=None) +def platform_headers(version: str, *, platform: Platform | None) -> Dict[str, str]: + return { + "X-Stainless-Lang": "python", + "X-Stainless-Package-Version": version, + "X-Stainless-OS": str(platform or get_platform()), + "X-Stainless-Arch": str(get_architecture()), + "X-Stainless-Runtime": get_python_runtime(), + "X-Stainless-Runtime-Version": get_python_version(), + } + + +class OtherArch: + def __init__(self, name: str) -> None: + self.name = name + + @override + def __str__(self) -> str: + return f"other:{self.name}" + + +Arch = Union[OtherArch, Literal["x32", "x64", "arm", "arm64", "unknown"]] + + +def get_python_runtime() -> str: + try: + return platform.python_implementation() + except Exception: + return "unknown" + + +def get_python_version() -> str: + try: + return platform.python_version() + except Exception: + return "unknown" + + +def get_architecture() -> Arch: + try: + machine = platform.machine().lower() + except Exception: + return "unknown" + + if machine in ("arm64", "aarch64"): + return "arm64" + + # TODO: untested + if machine == "arm": + return "arm" + + if machine == "x86_64": + return "x64" + + # TODO: untested + if sys.maxsize <= 2**32: + return "x32" + + if machine: + return OtherArch(machine) + + return "unknown" + + +def _merge_mappings( + obj1: Mapping[_T_co, Union[_T, Omit]], + obj2: Mapping[_T_co, Union[_T, Omit]], +) -> Dict[_T_co, _T]: + """Merge two mappings of the same type, removing any values that are instances of `Omit`. + + In cases with duplicate keys the second mapping takes precedence. + """ + merged = {**obj1, **obj2} + return {key: value for key, value in merged.items() if not isinstance(value, Omit)} diff --git a/src/agentex_sdk/_client.py b/src/agentex_sdk/_client.py new file mode 100644 index 00000000..d992c5f8 --- /dev/null +++ b/src/agentex_sdk/_client.py @@ -0,0 +1,544 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, Union, Mapping +from typing_extensions import Self, override + +import httpx + +from . import _exceptions +from ._qs import Querystring +from ._types import ( + NOT_GIVEN, + Body, + Omit, + Query, + Headers, + Timeout, + NotGiven, + Transport, + ProxiesTypes, + RequestOptions, +) +from ._utils import is_given, get_async_library +from ._version import __version__ +from ._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from .resources import echo, spans, events, states, tracker +from ._streaming import Stream as Stream, AsyncStream as AsyncStream +from ._exceptions import APIStatusError +from ._base_client import ( + DEFAULT_MAX_RETRIES, + SyncAPIClient, + AsyncAPIClient, + make_request_options, +) +from .resources.tasks import tasks +from .resources.agents import agents +from .resources.messages import messages + +__all__ = [ + "Timeout", + "Transport", + "ProxiesTypes", + "RequestOptions", + "AgentexSDK", + "AsyncAgentexSDK", + "Client", + "AsyncClient", +] + + +class AgentexSDK(SyncAPIClient): + echo: echo.EchoResource + agents: agents.AgentsResource + tasks: tasks.TasksResource + messages: messages.MessagesResource + spans: spans.SpansResource + states: states.StatesResource + events: events.EventsResource + tracker: tracker.TrackerResource + with_raw_response: AgentexSDKWithRawResponse + with_streaming_response: AgentexSDKWithStreamedResponse + + # client options + api_key: str | None + + def __init__( + self, + *, + api_key: str | None = None, + base_url: str | httpx.URL | None = None, + timeout: Union[float, Timeout, None, NotGiven] = NOT_GIVEN, + max_retries: int = DEFAULT_MAX_RETRIES, + default_headers: Mapping[str, str] | None = None, + default_query: Mapping[str, object] | None = None, + # Configure a custom httpx client. + # We provide a `DefaultHttpxClient` class that you can pass to retain the default values we use for `limits`, `timeout` & `follow_redirects`. + # See the [httpx documentation](https://www.python-httpx.org/api/#client) for more details. + http_client: httpx.Client | None = None, + # Enable or disable schema validation for data returned by the API. + # When enabled an error APIResponseValidationError is raised + # if the API responds with invalid data for the expected schema. + # + # This parameter may be removed or changed in the future. + # If you rely on this feature, please open a GitHub issue + # outlining your use-case to help us decide if it should be + # part of our public interface in the future. + _strict_response_validation: bool = False, + ) -> None: + """Construct a new synchronous AgentexSDK client instance. + + This automatically infers the `api_key` argument from the `AGENTEX_SDK_API_KEY` environment variable if it is not provided. + """ + if api_key is None: + api_key = os.environ.get("AGENTEX_SDK_API_KEY") + self.api_key = api_key + + if base_url is None: + base_url = os.environ.get("AGENTEX_SDK_BASE_URL") + if base_url is None: + base_url = f"https://api.example.com" + + super().__init__( + version=__version__, + base_url=base_url, + max_retries=max_retries, + timeout=timeout, + http_client=http_client, + custom_headers=default_headers, + custom_query=default_query, + _strict_response_validation=_strict_response_validation, + ) + + self.echo = echo.EchoResource(self) + self.agents = agents.AgentsResource(self) + self.tasks = tasks.TasksResource(self) + self.messages = messages.MessagesResource(self) + self.spans = spans.SpansResource(self) + self.states = states.StatesResource(self) + self.events = events.EventsResource(self) + self.tracker = tracker.TrackerResource(self) + self.with_raw_response = AgentexSDKWithRawResponse(self) + self.with_streaming_response = AgentexSDKWithStreamedResponse(self) + + @property + @override + def qs(self) -> Querystring: + return Querystring(array_format="comma") + + @property + @override + def auth_headers(self) -> dict[str, str]: + api_key = self.api_key + if api_key is None: + return {} + return {"Authorization": f"Bearer {api_key}"} + + @property + @override + def default_headers(self) -> dict[str, str | Omit]: + return { + **super().default_headers, + "X-Stainless-Async": "false", + **self._custom_headers, + } + + @override + def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None: + if self.api_key and headers.get("Authorization"): + return + if isinstance(custom_headers.get("Authorization"), Omit): + return + + raise TypeError( + '"Could not resolve authentication method. Expected the api_key to be set. Or for the `Authorization` headers to be explicitly omitted"' + ) + + def copy( + self, + *, + api_key: str | None = None, + base_url: str | httpx.URL | None = None, + timeout: float | Timeout | None | NotGiven = NOT_GIVEN, + http_client: httpx.Client | None = None, + max_retries: int | NotGiven = NOT_GIVEN, + default_headers: Mapping[str, str] | None = None, + set_default_headers: Mapping[str, str] | None = None, + default_query: Mapping[str, object] | None = None, + set_default_query: Mapping[str, object] | None = None, + _extra_kwargs: Mapping[str, Any] = {}, + ) -> Self: + """ + Create a new client instance re-using the same options given to the current client with optional overriding. + """ + if default_headers is not None and set_default_headers is not None: + raise ValueError("The `default_headers` and `set_default_headers` arguments are mutually exclusive") + + if default_query is not None and set_default_query is not None: + raise ValueError("The `default_query` and `set_default_query` arguments are mutually exclusive") + + headers = self._custom_headers + if default_headers is not None: + headers = {**headers, **default_headers} + elif set_default_headers is not None: + headers = set_default_headers + + params = self._custom_query + if default_query is not None: + params = {**params, **default_query} + elif set_default_query is not None: + params = set_default_query + + http_client = http_client or self._client + return self.__class__( + api_key=api_key or self.api_key, + base_url=base_url or self.base_url, + timeout=self.timeout if isinstance(timeout, NotGiven) else timeout, + http_client=http_client, + max_retries=max_retries if is_given(max_retries) else self.max_retries, + default_headers=headers, + default_query=params, + **_extra_kwargs, + ) + + # Alias for `copy` for nicer inline usage, e.g. + # client.with_options(timeout=10).foo.create(...) + with_options = copy + + def get_root( + self, + *, + # 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, + ) -> object: + """Root""" + return self.get( + "/", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + ) + + @override + def _make_status_error( + self, + err_msg: str, + *, + body: object, + response: httpx.Response, + ) -> APIStatusError: + if response.status_code == 400: + return _exceptions.BadRequestError(err_msg, response=response, body=body) + + if response.status_code == 401: + return _exceptions.AuthenticationError(err_msg, response=response, body=body) + + if response.status_code == 403: + return _exceptions.PermissionDeniedError(err_msg, response=response, body=body) + + if response.status_code == 404: + return _exceptions.NotFoundError(err_msg, response=response, body=body) + + if response.status_code == 409: + return _exceptions.ConflictError(err_msg, response=response, body=body) + + if response.status_code == 422: + return _exceptions.UnprocessableEntityError(err_msg, response=response, body=body) + + if response.status_code == 429: + return _exceptions.RateLimitError(err_msg, response=response, body=body) + + if response.status_code >= 500: + return _exceptions.InternalServerError(err_msg, response=response, body=body) + return APIStatusError(err_msg, response=response, body=body) + + +class AsyncAgentexSDK(AsyncAPIClient): + echo: echo.AsyncEchoResource + agents: agents.AsyncAgentsResource + tasks: tasks.AsyncTasksResource + messages: messages.AsyncMessagesResource + spans: spans.AsyncSpansResource + states: states.AsyncStatesResource + events: events.AsyncEventsResource + tracker: tracker.AsyncTrackerResource + with_raw_response: AsyncAgentexSDKWithRawResponse + with_streaming_response: AsyncAgentexSDKWithStreamedResponse + + # client options + api_key: str | None + + def __init__( + self, + *, + api_key: str | None = None, + base_url: str | httpx.URL | None = None, + timeout: Union[float, Timeout, None, NotGiven] = NOT_GIVEN, + max_retries: int = DEFAULT_MAX_RETRIES, + default_headers: Mapping[str, str] | None = None, + default_query: Mapping[str, object] | None = None, + # Configure a custom httpx client. + # We provide a `DefaultAsyncHttpxClient` class that you can pass to retain the default values we use for `limits`, `timeout` & `follow_redirects`. + # See the [httpx documentation](https://www.python-httpx.org/api/#asyncclient) for more details. + http_client: httpx.AsyncClient | None = None, + # Enable or disable schema validation for data returned by the API. + # When enabled an error APIResponseValidationError is raised + # if the API responds with invalid data for the expected schema. + # + # This parameter may be removed or changed in the future. + # If you rely on this feature, please open a GitHub issue + # outlining your use-case to help us decide if it should be + # part of our public interface in the future. + _strict_response_validation: bool = False, + ) -> None: + """Construct a new async AsyncAgentexSDK client instance. + + This automatically infers the `api_key` argument from the `AGENTEX_SDK_API_KEY` environment variable if it is not provided. + """ + if api_key is None: + api_key = os.environ.get("AGENTEX_SDK_API_KEY") + self.api_key = api_key + + if base_url is None: + base_url = os.environ.get("AGENTEX_SDK_BASE_URL") + if base_url is None: + base_url = f"https://api.example.com" + + super().__init__( + version=__version__, + base_url=base_url, + max_retries=max_retries, + timeout=timeout, + http_client=http_client, + custom_headers=default_headers, + custom_query=default_query, + _strict_response_validation=_strict_response_validation, + ) + + self.echo = echo.AsyncEchoResource(self) + self.agents = agents.AsyncAgentsResource(self) + self.tasks = tasks.AsyncTasksResource(self) + self.messages = messages.AsyncMessagesResource(self) + self.spans = spans.AsyncSpansResource(self) + self.states = states.AsyncStatesResource(self) + self.events = events.AsyncEventsResource(self) + self.tracker = tracker.AsyncTrackerResource(self) + self.with_raw_response = AsyncAgentexSDKWithRawResponse(self) + self.with_streaming_response = AsyncAgentexSDKWithStreamedResponse(self) + + @property + @override + def qs(self) -> Querystring: + return Querystring(array_format="comma") + + @property + @override + def auth_headers(self) -> dict[str, str]: + api_key = self.api_key + if api_key is None: + return {} + return {"Authorization": f"Bearer {api_key}"} + + @property + @override + def default_headers(self) -> dict[str, str | Omit]: + return { + **super().default_headers, + "X-Stainless-Async": f"async:{get_async_library()}", + **self._custom_headers, + } + + @override + def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None: + if self.api_key and headers.get("Authorization"): + return + if isinstance(custom_headers.get("Authorization"), Omit): + return + + raise TypeError( + '"Could not resolve authentication method. Expected the api_key to be set. Or for the `Authorization` headers to be explicitly omitted"' + ) + + def copy( + self, + *, + api_key: str | None = None, + base_url: str | httpx.URL | None = None, + timeout: float | Timeout | None | NotGiven = NOT_GIVEN, + http_client: httpx.AsyncClient | None = None, + max_retries: int | NotGiven = NOT_GIVEN, + default_headers: Mapping[str, str] | None = None, + set_default_headers: Mapping[str, str] | None = None, + default_query: Mapping[str, object] | None = None, + set_default_query: Mapping[str, object] | None = None, + _extra_kwargs: Mapping[str, Any] = {}, + ) -> Self: + """ + Create a new client instance re-using the same options given to the current client with optional overriding. + """ + if default_headers is not None and set_default_headers is not None: + raise ValueError("The `default_headers` and `set_default_headers` arguments are mutually exclusive") + + if default_query is not None and set_default_query is not None: + raise ValueError("The `default_query` and `set_default_query` arguments are mutually exclusive") + + headers = self._custom_headers + if default_headers is not None: + headers = {**headers, **default_headers} + elif set_default_headers is not None: + headers = set_default_headers + + params = self._custom_query + if default_query is not None: + params = {**params, **default_query} + elif set_default_query is not None: + params = set_default_query + + http_client = http_client or self._client + return self.__class__( + api_key=api_key or self.api_key, + base_url=base_url or self.base_url, + timeout=self.timeout if isinstance(timeout, NotGiven) else timeout, + http_client=http_client, + max_retries=max_retries if is_given(max_retries) else self.max_retries, + default_headers=headers, + default_query=params, + **_extra_kwargs, + ) + + # Alias for `copy` for nicer inline usage, e.g. + # client.with_options(timeout=10).foo.create(...) + with_options = copy + + async def get_root( + self, + *, + # 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, + ) -> object: + """Root""" + return await self.get( + "/", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + ) + + @override + def _make_status_error( + self, + err_msg: str, + *, + body: object, + response: httpx.Response, + ) -> APIStatusError: + if response.status_code == 400: + return _exceptions.BadRequestError(err_msg, response=response, body=body) + + if response.status_code == 401: + return _exceptions.AuthenticationError(err_msg, response=response, body=body) + + if response.status_code == 403: + return _exceptions.PermissionDeniedError(err_msg, response=response, body=body) + + if response.status_code == 404: + return _exceptions.NotFoundError(err_msg, response=response, body=body) + + if response.status_code == 409: + return _exceptions.ConflictError(err_msg, response=response, body=body) + + if response.status_code == 422: + return _exceptions.UnprocessableEntityError(err_msg, response=response, body=body) + + if response.status_code == 429: + return _exceptions.RateLimitError(err_msg, response=response, body=body) + + if response.status_code >= 500: + return _exceptions.InternalServerError(err_msg, response=response, body=body) + return APIStatusError(err_msg, response=response, body=body) + + +class AgentexSDKWithRawResponse: + def __init__(self, client: AgentexSDK) -> None: + self.echo = echo.EchoResourceWithRawResponse(client.echo) + self.agents = agents.AgentsResourceWithRawResponse(client.agents) + self.tasks = tasks.TasksResourceWithRawResponse(client.tasks) + self.messages = messages.MessagesResourceWithRawResponse(client.messages) + self.spans = spans.SpansResourceWithRawResponse(client.spans) + self.states = states.StatesResourceWithRawResponse(client.states) + self.events = events.EventsResourceWithRawResponse(client.events) + self.tracker = tracker.TrackerResourceWithRawResponse(client.tracker) + + self.get_root = to_raw_response_wrapper( + client.get_root, + ) + + +class AsyncAgentexSDKWithRawResponse: + def __init__(self, client: AsyncAgentexSDK) -> None: + self.echo = echo.AsyncEchoResourceWithRawResponse(client.echo) + self.agents = agents.AsyncAgentsResourceWithRawResponse(client.agents) + self.tasks = tasks.AsyncTasksResourceWithRawResponse(client.tasks) + self.messages = messages.AsyncMessagesResourceWithRawResponse(client.messages) + self.spans = spans.AsyncSpansResourceWithRawResponse(client.spans) + self.states = states.AsyncStatesResourceWithRawResponse(client.states) + self.events = events.AsyncEventsResourceWithRawResponse(client.events) + self.tracker = tracker.AsyncTrackerResourceWithRawResponse(client.tracker) + + self.get_root = async_to_raw_response_wrapper( + client.get_root, + ) + + +class AgentexSDKWithStreamedResponse: + def __init__(self, client: AgentexSDK) -> None: + self.echo = echo.EchoResourceWithStreamingResponse(client.echo) + self.agents = agents.AgentsResourceWithStreamingResponse(client.agents) + self.tasks = tasks.TasksResourceWithStreamingResponse(client.tasks) + self.messages = messages.MessagesResourceWithStreamingResponse(client.messages) + self.spans = spans.SpansResourceWithStreamingResponse(client.spans) + self.states = states.StatesResourceWithStreamingResponse(client.states) + self.events = events.EventsResourceWithStreamingResponse(client.events) + self.tracker = tracker.TrackerResourceWithStreamingResponse(client.tracker) + + self.get_root = to_streamed_response_wrapper( + client.get_root, + ) + + +class AsyncAgentexSDKWithStreamedResponse: + def __init__(self, client: AsyncAgentexSDK) -> None: + self.echo = echo.AsyncEchoResourceWithStreamingResponse(client.echo) + self.agents = agents.AsyncAgentsResourceWithStreamingResponse(client.agents) + self.tasks = tasks.AsyncTasksResourceWithStreamingResponse(client.tasks) + self.messages = messages.AsyncMessagesResourceWithStreamingResponse(client.messages) + self.spans = spans.AsyncSpansResourceWithStreamingResponse(client.spans) + self.states = states.AsyncStatesResourceWithStreamingResponse(client.states) + self.events = events.AsyncEventsResourceWithStreamingResponse(client.events) + self.tracker = tracker.AsyncTrackerResourceWithStreamingResponse(client.tracker) + + self.get_root = async_to_streamed_response_wrapper( + client.get_root, + ) + + +Client = AgentexSDK + +AsyncClient = AsyncAgentexSDK diff --git a/src/agentex_sdk/_compat.py b/src/agentex_sdk/_compat.py new file mode 100644 index 00000000..92d9ee61 --- /dev/null +++ b/src/agentex_sdk/_compat.py @@ -0,0 +1,219 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, Union, Generic, TypeVar, Callable, cast, overload +from datetime import date, datetime +from typing_extensions import Self, Literal + +import pydantic +from pydantic.fields import FieldInfo + +from ._types import IncEx, StrBytesIntFloat + +_T = TypeVar("_T") +_ModelT = TypeVar("_ModelT", bound=pydantic.BaseModel) + +# --------------- Pydantic v2 compatibility --------------- + +# Pyright incorrectly reports some of our functions as overriding a method when they don't +# pyright: reportIncompatibleMethodOverride=false + +PYDANTIC_V2 = pydantic.VERSION.startswith("2.") + +# v1 re-exports +if TYPE_CHECKING: + + def parse_date(value: date | StrBytesIntFloat) -> date: # noqa: ARG001 + ... + + def parse_datetime(value: Union[datetime, StrBytesIntFloat]) -> datetime: # noqa: ARG001 + ... + + def get_args(t: type[Any]) -> tuple[Any, ...]: # noqa: ARG001 + ... + + def is_union(tp: type[Any] | None) -> bool: # noqa: ARG001 + ... + + def get_origin(t: type[Any]) -> type[Any] | None: # noqa: ARG001 + ... + + def is_literal_type(type_: type[Any]) -> bool: # noqa: ARG001 + ... + + def is_typeddict(type_: type[Any]) -> bool: # noqa: ARG001 + ... + +else: + if PYDANTIC_V2: + from pydantic.v1.typing import ( + get_args as get_args, + is_union as is_union, + get_origin as get_origin, + is_typeddict as is_typeddict, + is_literal_type as is_literal_type, + ) + from pydantic.v1.datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime + else: + from pydantic.typing import ( + get_args as get_args, + is_union as is_union, + get_origin as get_origin, + is_typeddict as is_typeddict, + is_literal_type as is_literal_type, + ) + from pydantic.datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime + + +# refactored config +if TYPE_CHECKING: + from pydantic import ConfigDict as ConfigDict +else: + if PYDANTIC_V2: + from pydantic import ConfigDict + else: + # TODO: provide an error message here? + ConfigDict = None + + +# renamed methods / properties +def parse_obj(model: type[_ModelT], value: object) -> _ModelT: + if PYDANTIC_V2: + return model.model_validate(value) + else: + return cast(_ModelT, model.parse_obj(value)) # pyright: ignore[reportDeprecated, reportUnnecessaryCast] + + +def field_is_required(field: FieldInfo) -> bool: + if PYDANTIC_V2: + return field.is_required() + return field.required # type: ignore + + +def field_get_default(field: FieldInfo) -> Any: + value = field.get_default() + if PYDANTIC_V2: + from pydantic_core import PydanticUndefined + + if value == PydanticUndefined: + return None + return value + return value + + +def field_outer_type(field: FieldInfo) -> Any: + if PYDANTIC_V2: + return field.annotation + return field.outer_type_ # type: ignore + + +def get_model_config(model: type[pydantic.BaseModel]) -> Any: + if PYDANTIC_V2: + return model.model_config + return model.__config__ # type: ignore + + +def get_model_fields(model: type[pydantic.BaseModel]) -> dict[str, FieldInfo]: + if PYDANTIC_V2: + return model.model_fields + return model.__fields__ # type: ignore + + +def model_copy(model: _ModelT, *, deep: bool = False) -> _ModelT: + if PYDANTIC_V2: + return model.model_copy(deep=deep) + return model.copy(deep=deep) # type: ignore + + +def model_json(model: pydantic.BaseModel, *, indent: int | None = None) -> str: + if PYDANTIC_V2: + return model.model_dump_json(indent=indent) + return model.json(indent=indent) # type: ignore + + +def model_dump( + model: pydantic.BaseModel, + *, + exclude: IncEx | None = None, + exclude_unset: bool = False, + exclude_defaults: bool = False, + warnings: bool = True, + mode: Literal["json", "python"] = "python", +) -> dict[str, Any]: + if PYDANTIC_V2 or hasattr(model, "model_dump"): + return model.model_dump( + mode=mode, + exclude=exclude, + exclude_unset=exclude_unset, + exclude_defaults=exclude_defaults, + # warnings are not supported in Pydantic v1 + warnings=warnings if PYDANTIC_V2 else True, + ) + return cast( + "dict[str, Any]", + model.dict( # pyright: ignore[reportDeprecated, reportUnnecessaryCast] + exclude=exclude, + exclude_unset=exclude_unset, + exclude_defaults=exclude_defaults, + ), + ) + + +def model_parse(model: type[_ModelT], data: Any) -> _ModelT: + if PYDANTIC_V2: + return model.model_validate(data) + return model.parse_obj(data) # pyright: ignore[reportDeprecated] + + +# generic models +if TYPE_CHECKING: + + class GenericModel(pydantic.BaseModel): ... + +else: + if PYDANTIC_V2: + # there no longer needs to be a distinction in v2 but + # we still have to create our own subclass to avoid + # inconsistent MRO ordering errors + class GenericModel(pydantic.BaseModel): ... + + else: + import pydantic.generics + + class GenericModel(pydantic.generics.GenericModel, pydantic.BaseModel): ... + + +# cached properties +if TYPE_CHECKING: + cached_property = property + + # we define a separate type (copied from typeshed) + # that represents that `cached_property` is `set`able + # at runtime, which differs from `@property`. + # + # this is a separate type as editors likely special case + # `@property` and we don't want to cause issues just to have + # more helpful internal types. + + class typed_cached_property(Generic[_T]): + func: Callable[[Any], _T] + attrname: str | None + + def __init__(self, func: Callable[[Any], _T]) -> None: ... + + @overload + def __get__(self, instance: None, owner: type[Any] | None = None) -> Self: ... + + @overload + def __get__(self, instance: object, owner: type[Any] | None = None) -> _T: ... + + def __get__(self, instance: object, owner: type[Any] | None = None) -> _T | Self: + raise NotImplementedError() + + def __set_name__(self, owner: type[Any], name: str) -> None: ... + + # __set__ is not defined at runtime, but @cached_property is designed to be settable + def __set__(self, instance: object, value: _T) -> None: ... +else: + from functools import cached_property as cached_property + + typed_cached_property = cached_property diff --git a/src/agentex_sdk/_constants.py b/src/agentex_sdk/_constants.py new file mode 100644 index 00000000..6ddf2c71 --- /dev/null +++ b/src/agentex_sdk/_constants.py @@ -0,0 +1,14 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import httpx + +RAW_RESPONSE_HEADER = "X-Stainless-Raw-Response" +OVERRIDE_CAST_TO_HEADER = "____stainless_override_cast_to" + +# default timeout is 1 minute +DEFAULT_TIMEOUT = httpx.Timeout(timeout=60, connect=5.0) +DEFAULT_MAX_RETRIES = 2 +DEFAULT_CONNECTION_LIMITS = httpx.Limits(max_connections=100, max_keepalive_connections=20) + +INITIAL_RETRY_DELAY = 0.5 +MAX_RETRY_DELAY = 8.0 diff --git a/src/agentex_sdk/_exceptions.py b/src/agentex_sdk/_exceptions.py new file mode 100644 index 00000000..bc245781 --- /dev/null +++ b/src/agentex_sdk/_exceptions.py @@ -0,0 +1,108 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Literal + +import httpx + +__all__ = [ + "BadRequestError", + "AuthenticationError", + "PermissionDeniedError", + "NotFoundError", + "ConflictError", + "UnprocessableEntityError", + "RateLimitError", + "InternalServerError", +] + + +class AgentexSDKError(Exception): + pass + + +class APIError(AgentexSDKError): + message: str + request: httpx.Request + + body: object | None + """The API response body. + + If the API responded with a valid JSON structure then this property will be the + decoded result. + + If it isn't a valid JSON structure then this will be the raw response. + + If there was no response associated with this error then it will be `None`. + """ + + def __init__(self, message: str, request: httpx.Request, *, body: object | None) -> None: # noqa: ARG002 + super().__init__(message) + self.request = request + self.message = message + self.body = body + + +class APIResponseValidationError(APIError): + response: httpx.Response + status_code: int + + def __init__(self, response: httpx.Response, body: object | None, *, message: str | None = None) -> None: + super().__init__(message or "Data returned by API invalid for expected schema.", response.request, body=body) + self.response = response + self.status_code = response.status_code + + +class APIStatusError(APIError): + """Raised when an API response has a status code of 4xx or 5xx.""" + + response: httpx.Response + status_code: int + + def __init__(self, message: str, *, response: httpx.Response, body: object | None) -> None: + super().__init__(message, response.request, body=body) + self.response = response + self.status_code = response.status_code + + +class APIConnectionError(APIError): + def __init__(self, *, message: str = "Connection error.", request: httpx.Request) -> None: + super().__init__(message, request, body=None) + + +class APITimeoutError(APIConnectionError): + def __init__(self, request: httpx.Request) -> None: + super().__init__(message="Request timed out.", request=request) + + +class BadRequestError(APIStatusError): + status_code: Literal[400] = 400 # pyright: ignore[reportIncompatibleVariableOverride] + + +class AuthenticationError(APIStatusError): + status_code: Literal[401] = 401 # pyright: ignore[reportIncompatibleVariableOverride] + + +class PermissionDeniedError(APIStatusError): + status_code: Literal[403] = 403 # pyright: ignore[reportIncompatibleVariableOverride] + + +class NotFoundError(APIStatusError): + status_code: Literal[404] = 404 # pyright: ignore[reportIncompatibleVariableOverride] + + +class ConflictError(APIStatusError): + status_code: Literal[409] = 409 # pyright: ignore[reportIncompatibleVariableOverride] + + +class UnprocessableEntityError(APIStatusError): + status_code: Literal[422] = 422 # pyright: ignore[reportIncompatibleVariableOverride] + + +class RateLimitError(APIStatusError): + status_code: Literal[429] = 429 # pyright: ignore[reportIncompatibleVariableOverride] + + +class InternalServerError(APIStatusError): + pass diff --git a/src/agentex_sdk/_files.py b/src/agentex_sdk/_files.py new file mode 100644 index 00000000..715cc207 --- /dev/null +++ b/src/agentex_sdk/_files.py @@ -0,0 +1,123 @@ +from __future__ import annotations + +import io +import os +import pathlib +from typing import overload +from typing_extensions import TypeGuard + +import anyio + +from ._types import ( + FileTypes, + FileContent, + RequestFiles, + HttpxFileTypes, + Base64FileInput, + HttpxFileContent, + HttpxRequestFiles, +) +from ._utils import is_tuple_t, is_mapping_t, is_sequence_t + + +def is_base64_file_input(obj: object) -> TypeGuard[Base64FileInput]: + return isinstance(obj, io.IOBase) or isinstance(obj, os.PathLike) + + +def is_file_content(obj: object) -> TypeGuard[FileContent]: + return ( + isinstance(obj, bytes) or isinstance(obj, tuple) or isinstance(obj, io.IOBase) or isinstance(obj, os.PathLike) + ) + + +def assert_is_file_content(obj: object, *, key: str | None = None) -> None: + if not is_file_content(obj): + prefix = f"Expected entry at `{key}`" if key is not None else f"Expected file input `{obj!r}`" + raise RuntimeError( + f"{prefix} to be bytes, an io.IOBase instance, PathLike or a tuple but received {type(obj)} instead." + ) from None + + +@overload +def to_httpx_files(files: None) -> None: ... + + +@overload +def to_httpx_files(files: RequestFiles) -> HttpxRequestFiles: ... + + +def to_httpx_files(files: RequestFiles | None) -> HttpxRequestFiles | None: + if files is None: + return None + + if is_mapping_t(files): + files = {key: _transform_file(file) for key, file in files.items()} + elif is_sequence_t(files): + files = [(key, _transform_file(file)) for key, file in files] + else: + raise TypeError(f"Unexpected file type input {type(files)}, expected mapping or sequence") + + return files + + +def _transform_file(file: FileTypes) -> HttpxFileTypes: + if is_file_content(file): + if isinstance(file, os.PathLike): + path = pathlib.Path(file) + return (path.name, path.read_bytes()) + + return file + + if is_tuple_t(file): + return (file[0], _read_file_content(file[1]), *file[2:]) + + raise TypeError(f"Expected file types input to be a FileContent type or to be a tuple") + + +def _read_file_content(file: FileContent) -> HttpxFileContent: + if isinstance(file, os.PathLike): + return pathlib.Path(file).read_bytes() + return file + + +@overload +async def async_to_httpx_files(files: None) -> None: ... + + +@overload +async def async_to_httpx_files(files: RequestFiles) -> HttpxRequestFiles: ... + + +async def async_to_httpx_files(files: RequestFiles | None) -> HttpxRequestFiles | None: + if files is None: + return None + + if is_mapping_t(files): + files = {key: await _async_transform_file(file) for key, file in files.items()} + elif is_sequence_t(files): + files = [(key, await _async_transform_file(file)) for key, file in files] + else: + raise TypeError("Unexpected file type input {type(files)}, expected mapping or sequence") + + return files + + +async def _async_transform_file(file: FileTypes) -> HttpxFileTypes: + if is_file_content(file): + if isinstance(file, os.PathLike): + path = anyio.Path(file) + return (path.name, await path.read_bytes()) + + return file + + if is_tuple_t(file): + return (file[0], await _async_read_file_content(file[1]), *file[2:]) + + raise TypeError(f"Expected file types input to be a FileContent type or to be a tuple") + + +async def _async_read_file_content(file: FileContent) -> HttpxFileContent: + if isinstance(file, os.PathLike): + return await anyio.Path(file).read_bytes() + + return file diff --git a/src/agentex_sdk/_models.py b/src/agentex_sdk/_models.py new file mode 100644 index 00000000..528d5680 --- /dev/null +++ b/src/agentex_sdk/_models.py @@ -0,0 +1,808 @@ +from __future__ import annotations + +import os +import inspect +from typing import TYPE_CHECKING, Any, Type, Union, Generic, TypeVar, Callable, Optional, cast +from datetime import date, datetime +from typing_extensions import ( + List, + Unpack, + Literal, + ClassVar, + Protocol, + Required, + ParamSpec, + TypedDict, + TypeGuard, + final, + override, + runtime_checkable, +) + +import pydantic +from pydantic.fields import FieldInfo + +from ._types import ( + Body, + IncEx, + Query, + ModelT, + Headers, + Timeout, + NotGiven, + AnyMapping, + HttpxRequestFiles, +) +from ._utils import ( + PropertyInfo, + is_list, + is_given, + json_safe, + lru_cache, + is_mapping, + parse_date, + coerce_boolean, + parse_datetime, + strip_not_given, + extract_type_arg, + is_annotated_type, + is_type_alias_type, + strip_annotated_type, +) +from ._compat import ( + PYDANTIC_V2, + ConfigDict, + GenericModel as BaseGenericModel, + get_args, + is_union, + parse_obj, + get_origin, + is_literal_type, + get_model_config, + get_model_fields, + field_get_default, +) +from ._constants import RAW_RESPONSE_HEADER + +if TYPE_CHECKING: + from pydantic_core.core_schema import ModelField, ModelSchema, LiteralSchema, ModelFieldsSchema + +__all__ = ["BaseModel", "GenericModel"] + +_T = TypeVar("_T") +_BaseModelT = TypeVar("_BaseModelT", bound="BaseModel") + +P = ParamSpec("P") + + +@runtime_checkable +class _ConfigProtocol(Protocol): + allow_population_by_field_name: bool + + +class BaseModel(pydantic.BaseModel): + if PYDANTIC_V2: + model_config: ClassVar[ConfigDict] = ConfigDict( + extra="allow", defer_build=coerce_boolean(os.environ.get("DEFER_PYDANTIC_BUILD", "true")) + ) + else: + + @property + @override + def model_fields_set(self) -> set[str]: + # a forwards-compat shim for pydantic v2 + return self.__fields_set__ # type: ignore + + class Config(pydantic.BaseConfig): # pyright: ignore[reportDeprecated] + extra: Any = pydantic.Extra.allow # type: ignore + + def to_dict( + self, + *, + mode: Literal["json", "python"] = "python", + use_api_names: bool = True, + exclude_unset: bool = True, + exclude_defaults: bool = False, + exclude_none: bool = False, + warnings: bool = True, + ) -> dict[str, object]: + """Recursively generate a dictionary representation of the model, optionally specifying which fields to include or exclude. + + By default, fields that were not set by the API will not be included, + and keys will match the API response, *not* the property names from the model. + + For example, if the API responds with `"fooBar": true` but we've defined a `foo_bar: bool` property, + the output will use the `"fooBar"` key (unless `use_api_names=False` is passed). + + Args: + mode: + If mode is 'json', the dictionary will only contain JSON serializable types. e.g. `datetime` will be turned into a string, `"2024-3-22T18:11:19.117000Z"`. + If mode is 'python', the dictionary may contain any Python objects. e.g. `datetime(2024, 3, 22)` + + use_api_names: Whether to use the key that the API responded with or the property name. Defaults to `True`. + exclude_unset: Whether to exclude fields that have not been explicitly set. + exclude_defaults: Whether to exclude fields that are set to their default value from the output. + exclude_none: Whether to exclude fields that have a value of `None` from the output. + warnings: Whether to log warnings when invalid fields are encountered. This is only supported in Pydantic v2. + """ + return self.model_dump( + mode=mode, + by_alias=use_api_names, + exclude_unset=exclude_unset, + exclude_defaults=exclude_defaults, + exclude_none=exclude_none, + warnings=warnings, + ) + + def to_json( + self, + *, + indent: int | None = 2, + use_api_names: bool = True, + exclude_unset: bool = True, + exclude_defaults: bool = False, + exclude_none: bool = False, + warnings: bool = True, + ) -> str: + """Generates a JSON string representing this model as it would be received from or sent to the API (but with indentation). + + By default, fields that were not set by the API will not be included, + and keys will match the API response, *not* the property names from the model. + + For example, if the API responds with `"fooBar": true` but we've defined a `foo_bar: bool` property, + the output will use the `"fooBar"` key (unless `use_api_names=False` is passed). + + Args: + indent: Indentation to use in the JSON output. If `None` is passed, the output will be compact. Defaults to `2` + use_api_names: Whether to use the key that the API responded with or the property name. Defaults to `True`. + exclude_unset: Whether to exclude fields that have not been explicitly set. + exclude_defaults: Whether to exclude fields that have the default value. + exclude_none: Whether to exclude fields that have a value of `None`. + warnings: Whether to show any warnings that occurred during serialization. This is only supported in Pydantic v2. + """ + return self.model_dump_json( + indent=indent, + by_alias=use_api_names, + exclude_unset=exclude_unset, + exclude_defaults=exclude_defaults, + exclude_none=exclude_none, + warnings=warnings, + ) + + @override + def __str__(self) -> str: + # mypy complains about an invalid self arg + return f"{self.__repr_name__()}({self.__repr_str__(', ')})" # type: ignore[misc] + + # Override the 'construct' method in a way that supports recursive parsing without validation. + # Based on https://github.com/samuelcolvin/pydantic/issues/1168#issuecomment-817742836. + @classmethod + @override + def construct( # pyright: ignore[reportIncompatibleMethodOverride] + __cls: Type[ModelT], + _fields_set: set[str] | None = None, + **values: object, + ) -> ModelT: + m = __cls.__new__(__cls) + fields_values: dict[str, object] = {} + + config = get_model_config(__cls) + populate_by_name = ( + config.allow_population_by_field_name + if isinstance(config, _ConfigProtocol) + else config.get("populate_by_name") + ) + + if _fields_set is None: + _fields_set = set() + + model_fields = get_model_fields(__cls) + for name, field in model_fields.items(): + key = field.alias + if key is None or (key not in values and populate_by_name): + key = name + + if key in values: + fields_values[name] = _construct_field(value=values[key], field=field, key=key) + _fields_set.add(name) + else: + fields_values[name] = field_get_default(field) + + _extra = {} + for key, value in values.items(): + if key not in model_fields: + if PYDANTIC_V2: + _extra[key] = value + else: + _fields_set.add(key) + fields_values[key] = value + + object.__setattr__(m, "__dict__", fields_values) + + if PYDANTIC_V2: + # these properties are copied from Pydantic's `model_construct()` method + object.__setattr__(m, "__pydantic_private__", None) + object.__setattr__(m, "__pydantic_extra__", _extra) + object.__setattr__(m, "__pydantic_fields_set__", _fields_set) + else: + # init_private_attributes() does not exist in v2 + m._init_private_attributes() # type: ignore + + # copied from Pydantic v1's `construct()` method + object.__setattr__(m, "__fields_set__", _fields_set) + + return m + + if not TYPE_CHECKING: + # type checkers incorrectly complain about this assignment + # because the type signatures are technically different + # although not in practice + model_construct = construct + + if not PYDANTIC_V2: + # we define aliases for some of the new pydantic v2 methods so + # that we can just document these methods without having to specify + # a specific pydantic version as some users may not know which + # pydantic version they are currently using + + @override + def model_dump( + self, + *, + mode: Literal["json", "python"] | str = "python", + include: IncEx | None = None, + exclude: IncEx | None = None, + by_alias: bool = False, + exclude_unset: bool = False, + exclude_defaults: bool = False, + exclude_none: bool = False, + round_trip: bool = False, + warnings: bool | Literal["none", "warn", "error"] = True, + context: dict[str, Any] | None = None, + serialize_as_any: bool = False, + ) -> dict[str, Any]: + """Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#modelmodel_dump + + Generate a dictionary representation of the model, optionally specifying which fields to include or exclude. + + Args: + mode: The mode in which `to_python` should run. + If mode is 'json', the dictionary will only contain JSON serializable types. + If mode is 'python', the dictionary may contain any Python objects. + include: A list of fields to include in the output. + exclude: A list of fields to exclude from the output. + by_alias: Whether to use the field's alias in the dictionary key if defined. + exclude_unset: Whether to exclude fields that are unset or None from the output. + exclude_defaults: Whether to exclude fields that are set to their default value from the output. + exclude_none: Whether to exclude fields that have a value of `None` from the output. + round_trip: Whether to enable serialization and deserialization round-trip support. + warnings: Whether to log warnings when invalid fields are encountered. + + Returns: + A dictionary representation of the model. + """ + if mode not in {"json", "python"}: + raise ValueError("mode must be either 'json' or 'python'") + if round_trip != False: + raise ValueError("round_trip is only supported in Pydantic v2") + if warnings != True: + raise ValueError("warnings is only supported in Pydantic v2") + if context is not None: + raise ValueError("context is only supported in Pydantic v2") + if serialize_as_any != False: + raise ValueError("serialize_as_any is only supported in Pydantic v2") + dumped = super().dict( # pyright: ignore[reportDeprecated] + include=include, + exclude=exclude, + by_alias=by_alias, + exclude_unset=exclude_unset, + exclude_defaults=exclude_defaults, + exclude_none=exclude_none, + ) + + return cast(dict[str, Any], json_safe(dumped)) if mode == "json" else dumped + + @override + def model_dump_json( + self, + *, + indent: int | None = None, + include: IncEx | None = None, + exclude: IncEx | None = None, + by_alias: bool = False, + exclude_unset: bool = False, + exclude_defaults: bool = False, + exclude_none: bool = False, + round_trip: bool = False, + warnings: bool | Literal["none", "warn", "error"] = True, + context: dict[str, Any] | None = None, + serialize_as_any: bool = False, + ) -> str: + """Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#modelmodel_dump_json + + Generates a JSON representation of the model using Pydantic's `to_json` method. + + Args: + indent: Indentation to use in the JSON output. If None is passed, the output will be compact. + include: Field(s) to include in the JSON output. Can take either a string or set of strings. + exclude: Field(s) to exclude from the JSON output. Can take either a string or set of strings. + by_alias: Whether to serialize using field aliases. + exclude_unset: Whether to exclude fields that have not been explicitly set. + exclude_defaults: Whether to exclude fields that have the default value. + exclude_none: Whether to exclude fields that have a value of `None`. + round_trip: Whether to use serialization/deserialization between JSON and class instance. + warnings: Whether to show any warnings that occurred during serialization. + + Returns: + A JSON string representation of the model. + """ + if round_trip != False: + raise ValueError("round_trip is only supported in Pydantic v2") + if warnings != True: + raise ValueError("warnings is only supported in Pydantic v2") + if context is not None: + raise ValueError("context is only supported in Pydantic v2") + if serialize_as_any != False: + raise ValueError("serialize_as_any is only supported in Pydantic v2") + return super().json( # type: ignore[reportDeprecated] + indent=indent, + include=include, + exclude=exclude, + by_alias=by_alias, + exclude_unset=exclude_unset, + exclude_defaults=exclude_defaults, + exclude_none=exclude_none, + ) + + +def _construct_field(value: object, field: FieldInfo, key: str) -> object: + if value is None: + return field_get_default(field) + + if PYDANTIC_V2: + type_ = field.annotation + else: + type_ = cast(type, field.outer_type_) # type: ignore + + if type_ is None: + raise RuntimeError(f"Unexpected field type is None for {key}") + + return construct_type(value=value, type_=type_, metadata=getattr(field, "metadata", None)) + + +def is_basemodel(type_: type) -> bool: + """Returns whether or not the given type is either a `BaseModel` or a union of `BaseModel`""" + if is_union(type_): + for variant in get_args(type_): + if is_basemodel(variant): + return True + + return False + + return is_basemodel_type(type_) + + +def is_basemodel_type(type_: type) -> TypeGuard[type[BaseModel] | type[GenericModel]]: + origin = get_origin(type_) or type_ + if not inspect.isclass(origin): + return False + return issubclass(origin, BaseModel) or issubclass(origin, GenericModel) + + +def build( + base_model_cls: Callable[P, _BaseModelT], + *args: P.args, + **kwargs: P.kwargs, +) -> _BaseModelT: + """Construct a BaseModel class without validation. + + This is useful for cases where you need to instantiate a `BaseModel` + from an API response as this provides type-safe params which isn't supported + by helpers like `construct_type()`. + + ```py + build(MyModel, my_field_a="foo", my_field_b=123) + ``` + """ + if args: + raise TypeError( + "Received positional arguments which are not supported; Keyword arguments must be used instead", + ) + + return cast(_BaseModelT, construct_type(type_=base_model_cls, value=kwargs)) + + +def construct_type_unchecked(*, value: object, type_: type[_T]) -> _T: + """Loose coercion to the expected type with construction of nested values. + + Note: the returned value from this function is not guaranteed to match the + given type. + """ + return cast(_T, construct_type(value=value, type_=type_)) + + +def construct_type(*, value: object, type_: object, metadata: Optional[List[Any]] = None) -> object: + """Loose coercion to the expected type with construction of nested values. + + If the given value does not match the expected type then it is returned as-is. + """ + + # store a reference to the original type we were given before we extract any inner + # types so that we can properly resolve forward references in `TypeAliasType` annotations + original_type = None + + # we allow `object` as the input type because otherwise, passing things like + # `Literal['value']` will be reported as a type error by type checkers + type_ = cast("type[object]", type_) + if is_type_alias_type(type_): + original_type = type_ # type: ignore[unreachable] + type_ = type_.__value__ # type: ignore[unreachable] + + # unwrap `Annotated[T, ...]` -> `T` + if metadata is not None: + meta: tuple[Any, ...] = tuple(metadata) + elif is_annotated_type(type_): + meta = get_args(type_)[1:] + type_ = extract_type_arg(type_, 0) + else: + meta = tuple() + + # we need to use the origin class for any types that are subscripted generics + # e.g. Dict[str, object] + origin = get_origin(type_) or type_ + args = get_args(type_) + + if is_union(origin): + try: + return validate_type(type_=cast("type[object]", original_type or type_), value=value) + except Exception: + pass + + # if the type is a discriminated union then we want to construct the right variant + # in the union, even if the data doesn't match exactly, otherwise we'd break code + # that relies on the constructed class types, e.g. + # + # class FooType: + # kind: Literal['foo'] + # value: str + # + # class BarType: + # kind: Literal['bar'] + # value: int + # + # without this block, if the data we get is something like `{'kind': 'bar', 'value': 'foo'}` then + # we'd end up constructing `FooType` when it should be `BarType`. + discriminator = _build_discriminated_union_meta(union=type_, meta_annotations=meta) + if discriminator and is_mapping(value): + variant_value = value.get(discriminator.field_alias_from or discriminator.field_name) + if variant_value and isinstance(variant_value, str): + variant_type = discriminator.mapping.get(variant_value) + if variant_type: + return construct_type(type_=variant_type, value=value) + + # if the data is not valid, use the first variant that doesn't fail while deserializing + for variant in args: + try: + return construct_type(value=value, type_=variant) + except Exception: + continue + + raise RuntimeError(f"Could not convert data into a valid instance of {type_}") + + if origin == dict: + if not is_mapping(value): + return value + + _, items_type = get_args(type_) # Dict[_, items_type] + return {key: construct_type(value=item, type_=items_type) for key, item in value.items()} + + if ( + not is_literal_type(type_) + and inspect.isclass(origin) + and (issubclass(origin, BaseModel) or issubclass(origin, GenericModel)) + ): + if is_list(value): + return [cast(Any, type_).construct(**entry) if is_mapping(entry) else entry for entry in value] + + if is_mapping(value): + if issubclass(type_, BaseModel): + return type_.construct(**value) # type: ignore[arg-type] + + return cast(Any, type_).construct(**value) + + if origin == list: + if not is_list(value): + return value + + inner_type = args[0] # List[inner_type] + return [construct_type(value=entry, type_=inner_type) for entry in value] + + if origin == float: + if isinstance(value, int): + coerced = float(value) + if coerced != value: + return value + return coerced + + return value + + if type_ == datetime: + try: + return parse_datetime(value) # type: ignore + except Exception: + return value + + if type_ == date: + try: + return parse_date(value) # type: ignore + except Exception: + return value + + return value + + +@runtime_checkable +class CachedDiscriminatorType(Protocol): + __discriminator__: DiscriminatorDetails + + +class DiscriminatorDetails: + field_name: str + """The name of the discriminator field in the variant class, e.g. + + ```py + class Foo(BaseModel): + type: Literal['foo'] + ``` + + Will result in field_name='type' + """ + + field_alias_from: str | None + """The name of the discriminator field in the API response, e.g. + + ```py + class Foo(BaseModel): + type: Literal['foo'] = Field(alias='type_from_api') + ``` + + Will result in field_alias_from='type_from_api' + """ + + mapping: dict[str, type] + """Mapping of discriminator value to variant type, e.g. + + {'foo': FooVariant, 'bar': BarVariant} + """ + + def __init__( + self, + *, + mapping: dict[str, type], + discriminator_field: str, + discriminator_alias: str | None, + ) -> None: + self.mapping = mapping + self.field_name = discriminator_field + self.field_alias_from = discriminator_alias + + +def _build_discriminated_union_meta(*, union: type, meta_annotations: tuple[Any, ...]) -> DiscriminatorDetails | None: + if isinstance(union, CachedDiscriminatorType): + return union.__discriminator__ + + discriminator_field_name: str | None = None + + for annotation in meta_annotations: + if isinstance(annotation, PropertyInfo) and annotation.discriminator is not None: + discriminator_field_name = annotation.discriminator + break + + if not discriminator_field_name: + return None + + mapping: dict[str, type] = {} + discriminator_alias: str | None = None + + for variant in get_args(union): + variant = strip_annotated_type(variant) + if is_basemodel_type(variant): + if PYDANTIC_V2: + field = _extract_field_schema_pv2(variant, discriminator_field_name) + if not field: + continue + + # Note: if one variant defines an alias then they all should + discriminator_alias = field.get("serialization_alias") + + field_schema = field["schema"] + + if field_schema["type"] == "literal": + for entry in cast("LiteralSchema", field_schema)["expected"]: + if isinstance(entry, str): + mapping[entry] = variant + else: + field_info = cast("dict[str, FieldInfo]", variant.__fields__).get(discriminator_field_name) # pyright: ignore[reportDeprecated, reportUnnecessaryCast] + if not field_info: + continue + + # Note: if one variant defines an alias then they all should + discriminator_alias = field_info.alias + + if (annotation := getattr(field_info, "annotation", None)) and is_literal_type(annotation): + for entry in get_args(annotation): + if isinstance(entry, str): + mapping[entry] = variant + + if not mapping: + return None + + details = DiscriminatorDetails( + mapping=mapping, + discriminator_field=discriminator_field_name, + discriminator_alias=discriminator_alias, + ) + cast(CachedDiscriminatorType, union).__discriminator__ = details + return details + + +def _extract_field_schema_pv2(model: type[BaseModel], field_name: str) -> ModelField | None: + schema = model.__pydantic_core_schema__ + if schema["type"] == "definitions": + schema = schema["schema"] + + if schema["type"] != "model": + return None + + schema = cast("ModelSchema", schema) + fields_schema = schema["schema"] + if fields_schema["type"] != "model-fields": + return None + + fields_schema = cast("ModelFieldsSchema", fields_schema) + field = fields_schema["fields"].get(field_name) + if not field: + return None + + return cast("ModelField", field) # pyright: ignore[reportUnnecessaryCast] + + +def validate_type(*, type_: type[_T], value: object) -> _T: + """Strict validation that the given value matches the expected type""" + if inspect.isclass(type_) and issubclass(type_, pydantic.BaseModel): + return cast(_T, parse_obj(type_, value)) + + return cast(_T, _validate_non_model_type(type_=type_, value=value)) + + +def set_pydantic_config(typ: Any, config: pydantic.ConfigDict) -> None: + """Add a pydantic config for the given type. + + Note: this is a no-op on Pydantic v1. + """ + setattr(typ, "__pydantic_config__", config) # noqa: B010 + + +# our use of subclassing here causes weirdness for type checkers, +# so we just pretend that we don't subclass +if TYPE_CHECKING: + GenericModel = BaseModel +else: + + class GenericModel(BaseGenericModel, BaseModel): + pass + + +if PYDANTIC_V2: + from pydantic import TypeAdapter as _TypeAdapter + + _CachedTypeAdapter = cast("TypeAdapter[object]", lru_cache(maxsize=None)(_TypeAdapter)) + + if TYPE_CHECKING: + from pydantic import TypeAdapter + else: + TypeAdapter = _CachedTypeAdapter + + def _validate_non_model_type(*, type_: type[_T], value: object) -> _T: + return TypeAdapter(type_).validate_python(value) + +elif not TYPE_CHECKING: # TODO: condition is weird + + class RootModel(GenericModel, Generic[_T]): + """Used as a placeholder to easily convert runtime types to a Pydantic format + to provide validation. + + For example: + ```py + validated = RootModel[int](__root__="5").__root__ + # validated: 5 + ``` + """ + + __root__: _T + + def _validate_non_model_type(*, type_: type[_T], value: object) -> _T: + model = _create_pydantic_model(type_).validate(value) + return cast(_T, model.__root__) + + def _create_pydantic_model(type_: _T) -> Type[RootModel[_T]]: + return RootModel[type_] # type: ignore + + +class FinalRequestOptionsInput(TypedDict, total=False): + method: Required[str] + url: Required[str] + params: Query + headers: Headers + max_retries: int + timeout: float | Timeout | None + files: HttpxRequestFiles | None + idempotency_key: str + json_data: Body + extra_json: AnyMapping + follow_redirects: bool + + +@final +class FinalRequestOptions(pydantic.BaseModel): + method: str + url: str + params: Query = {} + headers: Union[Headers, NotGiven] = NotGiven() + max_retries: Union[int, NotGiven] = NotGiven() + timeout: Union[float, Timeout, None, NotGiven] = NotGiven() + files: Union[HttpxRequestFiles, None] = None + idempotency_key: Union[str, None] = None + post_parser: Union[Callable[[Any], Any], NotGiven] = NotGiven() + follow_redirects: Union[bool, None] = None + + # It should be noted that we cannot use `json` here as that would override + # a BaseModel method in an incompatible fashion. + json_data: Union[Body, None] = None + extra_json: Union[AnyMapping, None] = None + + if PYDANTIC_V2: + model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True) + else: + + class Config(pydantic.BaseConfig): # pyright: ignore[reportDeprecated] + arbitrary_types_allowed: bool = True + + def get_max_retries(self, max_retries: int) -> int: + if isinstance(self.max_retries, NotGiven): + return max_retries + return self.max_retries + + def _strip_raw_response_header(self) -> None: + if not is_given(self.headers): + return + + if self.headers.get(RAW_RESPONSE_HEADER): + self.headers = {**self.headers} + self.headers.pop(RAW_RESPONSE_HEADER) + + # override the `construct` method so that we can run custom transformations. + # this is necessary as we don't want to do any actual runtime type checking + # (which means we can't use validators) but we do want to ensure that `NotGiven` + # values are not present + # + # type ignore required because we're adding explicit types to `**values` + @classmethod + def construct( # type: ignore + cls, + _fields_set: set[str] | None = None, + **values: Unpack[FinalRequestOptionsInput], + ) -> FinalRequestOptions: + kwargs: dict[str, Any] = { + # we unconditionally call `strip_not_given` on any value + # as it will just ignore any non-mapping types + key: strip_not_given(value) + for key, value in values.items() + } + if PYDANTIC_V2: + return super().model_construct(_fields_set, **kwargs) + return cast(FinalRequestOptions, super().construct(_fields_set, **kwargs)) # pyright: ignore[reportDeprecated] + + if not TYPE_CHECKING: + # type checkers incorrectly complain about this assignment + model_construct = construct diff --git a/src/agentex_sdk/_qs.py b/src/agentex_sdk/_qs.py new file mode 100644 index 00000000..274320ca --- /dev/null +++ b/src/agentex_sdk/_qs.py @@ -0,0 +1,150 @@ +from __future__ import annotations + +from typing import Any, List, Tuple, Union, Mapping, TypeVar +from urllib.parse import parse_qs, urlencode +from typing_extensions import Literal, get_args + +from ._types import NOT_GIVEN, NotGiven, NotGivenOr +from ._utils import flatten + +_T = TypeVar("_T") + + +ArrayFormat = Literal["comma", "repeat", "indices", "brackets"] +NestedFormat = Literal["dots", "brackets"] + +PrimitiveData = Union[str, int, float, bool, None] +# this should be Data = Union[PrimitiveData, "List[Data]", "Tuple[Data]", "Mapping[str, Data]"] +# https://github.com/microsoft/pyright/issues/3555 +Data = Union[PrimitiveData, List[Any], Tuple[Any], "Mapping[str, Any]"] +Params = Mapping[str, Data] + + +class Querystring: + array_format: ArrayFormat + nested_format: NestedFormat + + def __init__( + self, + *, + array_format: ArrayFormat = "repeat", + nested_format: NestedFormat = "brackets", + ) -> None: + self.array_format = array_format + self.nested_format = nested_format + + def parse(self, query: str) -> Mapping[str, object]: + # Note: custom format syntax is not supported yet + return parse_qs(query) + + def stringify( + self, + params: Params, + *, + array_format: NotGivenOr[ArrayFormat] = NOT_GIVEN, + nested_format: NotGivenOr[NestedFormat] = NOT_GIVEN, + ) -> str: + return urlencode( + self.stringify_items( + params, + array_format=array_format, + nested_format=nested_format, + ) + ) + + def stringify_items( + self, + params: Params, + *, + array_format: NotGivenOr[ArrayFormat] = NOT_GIVEN, + nested_format: NotGivenOr[NestedFormat] = NOT_GIVEN, + ) -> list[tuple[str, str]]: + opts = Options( + qs=self, + array_format=array_format, + nested_format=nested_format, + ) + return flatten([self._stringify_item(key, value, opts) for key, value in params.items()]) + + def _stringify_item( + self, + key: str, + value: Data, + opts: Options, + ) -> list[tuple[str, str]]: + if isinstance(value, Mapping): + items: list[tuple[str, str]] = [] + nested_format = opts.nested_format + for subkey, subvalue in value.items(): + items.extend( + self._stringify_item( + # TODO: error if unknown format + f"{key}.{subkey}" if nested_format == "dots" else f"{key}[{subkey}]", + subvalue, + opts, + ) + ) + return items + + if isinstance(value, (list, tuple)): + array_format = opts.array_format + if array_format == "comma": + return [ + ( + key, + ",".join(self._primitive_value_to_str(item) for item in value if item is not None), + ), + ] + elif array_format == "repeat": + items = [] + for item in value: + items.extend(self._stringify_item(key, item, opts)) + return items + elif array_format == "indices": + raise NotImplementedError("The array indices format is not supported yet") + elif array_format == "brackets": + items = [] + key = key + "[]" + for item in value: + items.extend(self._stringify_item(key, item, opts)) + return items + else: + raise NotImplementedError( + f"Unknown array_format value: {array_format}, choose from {', '.join(get_args(ArrayFormat))}" + ) + + serialised = self._primitive_value_to_str(value) + if not serialised: + return [] + return [(key, serialised)] + + def _primitive_value_to_str(self, value: PrimitiveData) -> str: + # copied from httpx + if value is True: + return "true" + elif value is False: + return "false" + elif value is None: + return "" + return str(value) + + +_qs = Querystring() +parse = _qs.parse +stringify = _qs.stringify +stringify_items = _qs.stringify_items + + +class Options: + array_format: ArrayFormat + nested_format: NestedFormat + + def __init__( + self, + qs: Querystring = _qs, + *, + array_format: NotGivenOr[ArrayFormat] = NOT_GIVEN, + nested_format: NotGivenOr[NestedFormat] = NOT_GIVEN, + ) -> None: + self.array_format = qs.array_format if isinstance(array_format, NotGiven) else array_format + self.nested_format = qs.nested_format if isinstance(nested_format, NotGiven) else nested_format diff --git a/src/agentex_sdk/_resource.py b/src/agentex_sdk/_resource.py new file mode 100644 index 00000000..cdad1ec0 --- /dev/null +++ b/src/agentex_sdk/_resource.py @@ -0,0 +1,43 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import time +from typing import TYPE_CHECKING + +import anyio + +if TYPE_CHECKING: + from ._client import AgentexSDK, AsyncAgentexSDK + + +class SyncAPIResource: + _client: AgentexSDK + + def __init__(self, client: AgentexSDK) -> None: + self._client = client + self._get = client.get + self._post = client.post + self._patch = client.patch + self._put = client.put + self._delete = client.delete + self._get_api_list = client.get_api_list + + def _sleep(self, seconds: float) -> None: + time.sleep(seconds) + + +class AsyncAPIResource: + _client: AsyncAgentexSDK + + def __init__(self, client: AsyncAgentexSDK) -> None: + self._client = client + self._get = client.get + self._post = client.post + self._patch = client.patch + self._put = client.put + self._delete = client.delete + self._get_api_list = client.get_api_list + + async def _sleep(self, seconds: float) -> None: + await anyio.sleep(seconds) diff --git a/src/agentex_sdk/_response.py b/src/agentex_sdk/_response.py new file mode 100644 index 00000000..d8115d31 --- /dev/null +++ b/src/agentex_sdk/_response.py @@ -0,0 +1,832 @@ +from __future__ import annotations + +import os +import inspect +import logging +import datetime +import functools +from types import TracebackType +from typing import ( + TYPE_CHECKING, + Any, + Union, + Generic, + TypeVar, + Callable, + Iterator, + AsyncIterator, + cast, + overload, +) +from typing_extensions import Awaitable, ParamSpec, override, get_origin + +import anyio +import httpx +import pydantic + +from ._types import NoneType +from ._utils import is_given, extract_type_arg, is_annotated_type, is_type_alias_type, extract_type_var_from_base +from ._models import BaseModel, is_basemodel +from ._constants import RAW_RESPONSE_HEADER, OVERRIDE_CAST_TO_HEADER +from ._streaming import Stream, AsyncStream, is_stream_class_type, extract_stream_chunk_type +from ._exceptions import AgentexSDKError, APIResponseValidationError + +if TYPE_CHECKING: + from ._models import FinalRequestOptions + from ._base_client import BaseClient + + +P = ParamSpec("P") +R = TypeVar("R") +_T = TypeVar("_T") +_APIResponseT = TypeVar("_APIResponseT", bound="APIResponse[Any]") +_AsyncAPIResponseT = TypeVar("_AsyncAPIResponseT", bound="AsyncAPIResponse[Any]") + +log: logging.Logger = logging.getLogger(__name__) + + +class BaseAPIResponse(Generic[R]): + _cast_to: type[R] + _client: BaseClient[Any, Any] + _parsed_by_type: dict[type[Any], Any] + _is_sse_stream: bool + _stream_cls: type[Stream[Any]] | type[AsyncStream[Any]] | None + _options: FinalRequestOptions + + http_response: httpx.Response + + retries_taken: int + """The number of retries made. If no retries happened this will be `0`""" + + def __init__( + self, + *, + raw: httpx.Response, + cast_to: type[R], + client: BaseClient[Any, Any], + stream: bool, + stream_cls: type[Stream[Any]] | type[AsyncStream[Any]] | None, + options: FinalRequestOptions, + retries_taken: int = 0, + ) -> None: + self._cast_to = cast_to + self._client = client + self._parsed_by_type = {} + self._is_sse_stream = stream + self._stream_cls = stream_cls + self._options = options + self.http_response = raw + self.retries_taken = retries_taken + + @property + def headers(self) -> httpx.Headers: + return self.http_response.headers + + @property + def http_request(self) -> httpx.Request: + """Returns the httpx Request instance associated with the current response.""" + return self.http_response.request + + @property + def status_code(self) -> int: + return self.http_response.status_code + + @property + def url(self) -> httpx.URL: + """Returns the URL for which the request was made.""" + return self.http_response.url + + @property + def method(self) -> str: + return self.http_request.method + + @property + def http_version(self) -> str: + return self.http_response.http_version + + @property + def elapsed(self) -> datetime.timedelta: + """The time taken for the complete request/response cycle to complete.""" + return self.http_response.elapsed + + @property + def is_closed(self) -> bool: + """Whether or not the response body has been closed. + + If this is False then there is response data that has not been read yet. + You must either fully consume the response body or call `.close()` + before discarding the response to prevent resource leaks. + """ + return self.http_response.is_closed + + @override + def __repr__(self) -> str: + return ( + f"<{self.__class__.__name__} [{self.status_code} {self.http_response.reason_phrase}] type={self._cast_to}>" + ) + + def _parse(self, *, to: type[_T] | None = None) -> R | _T: + cast_to = to if to is not None else self._cast_to + + # unwrap `TypeAlias('Name', T)` -> `T` + if is_type_alias_type(cast_to): + cast_to = cast_to.__value__ # type: ignore[unreachable] + + # unwrap `Annotated[T, ...]` -> `T` + if cast_to and is_annotated_type(cast_to): + cast_to = extract_type_arg(cast_to, 0) + + origin = get_origin(cast_to) or cast_to + + if self._is_sse_stream: + if to: + if not is_stream_class_type(to): + raise TypeError(f"Expected custom parse type to be a subclass of {Stream} or {AsyncStream}") + + return cast( + _T, + to( + cast_to=extract_stream_chunk_type( + to, + failure_message="Expected custom stream type to be passed with a type argument, e.g. Stream[ChunkType]", + ), + response=self.http_response, + client=cast(Any, self._client), + ), + ) + + if self._stream_cls: + return cast( + R, + self._stream_cls( + cast_to=extract_stream_chunk_type(self._stream_cls), + response=self.http_response, + client=cast(Any, self._client), + ), + ) + + stream_cls = cast("type[Stream[Any]] | type[AsyncStream[Any]] | None", self._client._default_stream_cls) + if stream_cls is None: + raise MissingStreamClassError() + + return cast( + R, + stream_cls( + cast_to=cast_to, + response=self.http_response, + client=cast(Any, self._client), + ), + ) + + if cast_to is NoneType: + return cast(R, None) + + response = self.http_response + if cast_to == str: + return cast(R, response.text) + + if cast_to == bytes: + return cast(R, response.content) + + if cast_to == int: + return cast(R, int(response.text)) + + if cast_to == float: + return cast(R, float(response.text)) + + if cast_to == bool: + return cast(R, response.text.lower() == "true") + + if origin == APIResponse: + raise RuntimeError("Unexpected state - cast_to is `APIResponse`") + + if inspect.isclass(origin) and issubclass(origin, httpx.Response): + # Because of the invariance of our ResponseT TypeVar, users can subclass httpx.Response + # and pass that class to our request functions. We cannot change the variance to be either + # covariant or contravariant as that makes our usage of ResponseT illegal. We could construct + # the response class ourselves but that is something that should be supported directly in httpx + # as it would be easy to incorrectly construct the Response object due to the multitude of arguments. + if cast_to != httpx.Response: + raise ValueError(f"Subclasses of httpx.Response cannot be passed to `cast_to`") + return cast(R, response) + + if ( + inspect.isclass( + origin # pyright: ignore[reportUnknownArgumentType] + ) + and not issubclass(origin, BaseModel) + and issubclass(origin, pydantic.BaseModel) + ): + raise TypeError( + "Pydantic models must subclass our base model type, e.g. `from agentex_sdk import BaseModel`" + ) + + if ( + cast_to is not object + and not origin is list + and not origin is dict + and not origin is Union + and not issubclass(origin, BaseModel) + ): + raise RuntimeError( + f"Unsupported type, expected {cast_to} to be a subclass of {BaseModel}, {dict}, {list}, {Union}, {NoneType}, {str} or {httpx.Response}." + ) + + # split is required to handle cases where additional information is included + # in the response, e.g. application/json; charset=utf-8 + content_type, *_ = response.headers.get("content-type", "*").split(";") + if not content_type.endswith("json"): + if is_basemodel(cast_to): + try: + data = response.json() + except Exception as exc: + log.debug("Could not read JSON from response data due to %s - %s", type(exc), exc) + else: + return self._client._process_response_data( + data=data, + cast_to=cast_to, # type: ignore + response=response, + ) + + if self._client._strict_response_validation: + raise APIResponseValidationError( + response=response, + message=f"Expected Content-Type response header to be `application/json` but received `{content_type}` instead.", + body=response.text, + ) + + # If the API responds with content that isn't JSON then we just return + # the (decoded) text without performing any parsing so that you can still + # handle the response however you need to. + return response.text # type: ignore + + data = response.json() + + return self._client._process_response_data( + data=data, + cast_to=cast_to, # type: ignore + response=response, + ) + + +class APIResponse(BaseAPIResponse[R]): + @overload + def parse(self, *, to: type[_T]) -> _T: ... + + @overload + def parse(self) -> R: ... + + def parse(self, *, to: type[_T] | None = None) -> R | _T: + """Returns the rich python representation of this response's data. + + For lower-level control, see `.read()`, `.json()`, `.iter_bytes()`. + + You can customise the type that the response is parsed into through + the `to` argument, e.g. + + ```py + from agentex_sdk import BaseModel + + + class MyModel(BaseModel): + foo: str + + + obj = response.parse(to=MyModel) + print(obj.foo) + ``` + + We support parsing: + - `BaseModel` + - `dict` + - `list` + - `Union` + - `str` + - `int` + - `float` + - `httpx.Response` + """ + cache_key = to if to is not None else self._cast_to + cached = self._parsed_by_type.get(cache_key) + if cached is not None: + return cached # type: ignore[no-any-return] + + if not self._is_sse_stream: + self.read() + + parsed = self._parse(to=to) + if is_given(self._options.post_parser): + parsed = self._options.post_parser(parsed) + + self._parsed_by_type[cache_key] = parsed + return parsed + + def read(self) -> bytes: + """Read and return the binary response content.""" + try: + return self.http_response.read() + except httpx.StreamConsumed as exc: + # The default error raised by httpx isn't very + # helpful in our case so we re-raise it with + # a different error message. + raise StreamAlreadyConsumed() from exc + + def text(self) -> str: + """Read and decode the response content into a string.""" + self.read() + return self.http_response.text + + def json(self) -> object: + """Read and decode the JSON response content.""" + self.read() + return self.http_response.json() + + def close(self) -> None: + """Close the response and release the connection. + + Automatically called if the response body is read to completion. + """ + self.http_response.close() + + def iter_bytes(self, chunk_size: int | None = None) -> Iterator[bytes]: + """ + A byte-iterator over the decoded response content. + + This automatically handles gzip, deflate and brotli encoded responses. + """ + for chunk in self.http_response.iter_bytes(chunk_size): + yield chunk + + def iter_text(self, chunk_size: int | None = None) -> Iterator[str]: + """A str-iterator over the decoded response content + that handles both gzip, deflate, etc but also detects the content's + string encoding. + """ + for chunk in self.http_response.iter_text(chunk_size): + yield chunk + + def iter_lines(self) -> Iterator[str]: + """Like `iter_text()` but will only yield chunks for each line""" + for chunk in self.http_response.iter_lines(): + yield chunk + + +class AsyncAPIResponse(BaseAPIResponse[R]): + @overload + async def parse(self, *, to: type[_T]) -> _T: ... + + @overload + async def parse(self) -> R: ... + + async def parse(self, *, to: type[_T] | None = None) -> R | _T: + """Returns the rich python representation of this response's data. + + For lower-level control, see `.read()`, `.json()`, `.iter_bytes()`. + + You can customise the type that the response is parsed into through + the `to` argument, e.g. + + ```py + from agentex_sdk import BaseModel + + + class MyModel(BaseModel): + foo: str + + + obj = response.parse(to=MyModel) + print(obj.foo) + ``` + + We support parsing: + - `BaseModel` + - `dict` + - `list` + - `Union` + - `str` + - `httpx.Response` + """ + cache_key = to if to is not None else self._cast_to + cached = self._parsed_by_type.get(cache_key) + if cached is not None: + return cached # type: ignore[no-any-return] + + if not self._is_sse_stream: + await self.read() + + parsed = self._parse(to=to) + if is_given(self._options.post_parser): + parsed = self._options.post_parser(parsed) + + self._parsed_by_type[cache_key] = parsed + return parsed + + async def read(self) -> bytes: + """Read and return the binary response content.""" + try: + return await self.http_response.aread() + except httpx.StreamConsumed as exc: + # the default error raised by httpx isn't very + # helpful in our case so we re-raise it with + # a different error message + raise StreamAlreadyConsumed() from exc + + async def text(self) -> str: + """Read and decode the response content into a string.""" + await self.read() + return self.http_response.text + + async def json(self) -> object: + """Read and decode the JSON response content.""" + await self.read() + return self.http_response.json() + + async def close(self) -> None: + """Close the response and release the connection. + + Automatically called if the response body is read to completion. + """ + await self.http_response.aclose() + + async def iter_bytes(self, chunk_size: int | None = None) -> AsyncIterator[bytes]: + """ + A byte-iterator over the decoded response content. + + This automatically handles gzip, deflate and brotli encoded responses. + """ + async for chunk in self.http_response.aiter_bytes(chunk_size): + yield chunk + + async def iter_text(self, chunk_size: int | None = None) -> AsyncIterator[str]: + """A str-iterator over the decoded response content + that handles both gzip, deflate, etc but also detects the content's + string encoding. + """ + async for chunk in self.http_response.aiter_text(chunk_size): + yield chunk + + async def iter_lines(self) -> AsyncIterator[str]: + """Like `iter_text()` but will only yield chunks for each line""" + async for chunk in self.http_response.aiter_lines(): + yield chunk + + +class BinaryAPIResponse(APIResponse[bytes]): + """Subclass of APIResponse providing helpers for dealing with binary data. + + Note: If you want to stream the response data instead of eagerly reading it + all at once then you should use `.with_streaming_response` when making + the API request, e.g. `.with_streaming_response.get_binary_response()` + """ + + def write_to_file( + self, + file: str | os.PathLike[str], + ) -> None: + """Write the output to the given file. + + Accepts a filename or any path-like object, e.g. pathlib.Path + + Note: if you want to stream the data to the file instead of writing + all at once then you should use `.with_streaming_response` when making + the API request, e.g. `.with_streaming_response.get_binary_response()` + """ + with open(file, mode="wb") as f: + for data in self.iter_bytes(): + f.write(data) + + +class AsyncBinaryAPIResponse(AsyncAPIResponse[bytes]): + """Subclass of APIResponse providing helpers for dealing with binary data. + + Note: If you want to stream the response data instead of eagerly reading it + all at once then you should use `.with_streaming_response` when making + the API request, e.g. `.with_streaming_response.get_binary_response()` + """ + + async def write_to_file( + self, + file: str | os.PathLike[str], + ) -> None: + """Write the output to the given file. + + Accepts a filename or any path-like object, e.g. pathlib.Path + + Note: if you want to stream the data to the file instead of writing + all at once then you should use `.with_streaming_response` when making + the API request, e.g. `.with_streaming_response.get_binary_response()` + """ + path = anyio.Path(file) + async with await path.open(mode="wb") as f: + async for data in self.iter_bytes(): + await f.write(data) + + +class StreamedBinaryAPIResponse(APIResponse[bytes]): + def stream_to_file( + self, + file: str | os.PathLike[str], + *, + chunk_size: int | None = None, + ) -> None: + """Streams the output to the given file. + + Accepts a filename or any path-like object, e.g. pathlib.Path + """ + with open(file, mode="wb") as f: + for data in self.iter_bytes(chunk_size): + f.write(data) + + +class AsyncStreamedBinaryAPIResponse(AsyncAPIResponse[bytes]): + async def stream_to_file( + self, + file: str | os.PathLike[str], + *, + chunk_size: int | None = None, + ) -> None: + """Streams the output to the given file. + + Accepts a filename or any path-like object, e.g. pathlib.Path + """ + path = anyio.Path(file) + async with await path.open(mode="wb") as f: + async for data in self.iter_bytes(chunk_size): + await f.write(data) + + +class MissingStreamClassError(TypeError): + def __init__(self) -> None: + super().__init__( + "The `stream` argument was set to `True` but the `stream_cls` argument was not given. See `agentex_sdk._streaming` for reference", + ) + + +class StreamAlreadyConsumed(AgentexSDKError): + """ + Attempted to read or stream content, but the content has already + been streamed. + + This can happen if you use a method like `.iter_lines()` and then attempt + to read th entire response body afterwards, e.g. + + ```py + response = await client.post(...) + async for line in response.iter_lines(): + ... # do something with `line` + + content = await response.read() + # ^ error + ``` + + If you want this behaviour you'll need to either manually accumulate the response + content or call `await response.read()` before iterating over the stream. + """ + + def __init__(self) -> None: + message = ( + "Attempted to read or stream some content, but the content has " + "already been streamed. " + "This could be due to attempting to stream the response " + "content more than once." + "\n\n" + "You can fix this by manually accumulating the response content while streaming " + "or by calling `.read()` before starting to stream." + ) + super().__init__(message) + + +class ResponseContextManager(Generic[_APIResponseT]): + """Context manager for ensuring that a request is not made + until it is entered and that the response will always be closed + when the context manager exits + """ + + def __init__(self, request_func: Callable[[], _APIResponseT]) -> None: + self._request_func = request_func + self.__response: _APIResponseT | None = None + + def __enter__(self) -> _APIResponseT: + self.__response = self._request_func() + return self.__response + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + if self.__response is not None: + self.__response.close() + + +class AsyncResponseContextManager(Generic[_AsyncAPIResponseT]): + """Context manager for ensuring that a request is not made + until it is entered and that the response will always be closed + when the context manager exits + """ + + def __init__(self, api_request: Awaitable[_AsyncAPIResponseT]) -> None: + self._api_request = api_request + self.__response: _AsyncAPIResponseT | None = None + + async def __aenter__(self) -> _AsyncAPIResponseT: + self.__response = await self._api_request + return self.__response + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + if self.__response is not None: + await self.__response.close() + + +def to_streamed_response_wrapper(func: Callable[P, R]) -> Callable[P, ResponseContextManager[APIResponse[R]]]: + """Higher order function that takes one of our bound API methods and wraps it + to support streaming and returning the raw `APIResponse` object directly. + """ + + @functools.wraps(func) + def wrapped(*args: P.args, **kwargs: P.kwargs) -> ResponseContextManager[APIResponse[R]]: + extra_headers: dict[str, str] = {**(cast(Any, kwargs.get("extra_headers")) or {})} + extra_headers[RAW_RESPONSE_HEADER] = "stream" + + kwargs["extra_headers"] = extra_headers + + make_request = functools.partial(func, *args, **kwargs) + + return ResponseContextManager(cast(Callable[[], APIResponse[R]], make_request)) + + return wrapped + + +def async_to_streamed_response_wrapper( + func: Callable[P, Awaitable[R]], +) -> Callable[P, AsyncResponseContextManager[AsyncAPIResponse[R]]]: + """Higher order function that takes one of our bound API methods and wraps it + to support streaming and returning the raw `APIResponse` object directly. + """ + + @functools.wraps(func) + def wrapped(*args: P.args, **kwargs: P.kwargs) -> AsyncResponseContextManager[AsyncAPIResponse[R]]: + extra_headers: dict[str, str] = {**(cast(Any, kwargs.get("extra_headers")) or {})} + extra_headers[RAW_RESPONSE_HEADER] = "stream" + + kwargs["extra_headers"] = extra_headers + + make_request = func(*args, **kwargs) + + return AsyncResponseContextManager(cast(Awaitable[AsyncAPIResponse[R]], make_request)) + + return wrapped + + +def to_custom_streamed_response_wrapper( + func: Callable[P, object], + response_cls: type[_APIResponseT], +) -> Callable[P, ResponseContextManager[_APIResponseT]]: + """Higher order function that takes one of our bound API methods and an `APIResponse` class + and wraps the method to support streaming and returning the given response class directly. + + Note: the given `response_cls` *must* be concrete, e.g. `class BinaryAPIResponse(APIResponse[bytes])` + """ + + @functools.wraps(func) + def wrapped(*args: P.args, **kwargs: P.kwargs) -> ResponseContextManager[_APIResponseT]: + extra_headers: dict[str, Any] = {**(cast(Any, kwargs.get("extra_headers")) or {})} + extra_headers[RAW_RESPONSE_HEADER] = "stream" + extra_headers[OVERRIDE_CAST_TO_HEADER] = response_cls + + kwargs["extra_headers"] = extra_headers + + make_request = functools.partial(func, *args, **kwargs) + + return ResponseContextManager(cast(Callable[[], _APIResponseT], make_request)) + + return wrapped + + +def async_to_custom_streamed_response_wrapper( + func: Callable[P, Awaitable[object]], + response_cls: type[_AsyncAPIResponseT], +) -> Callable[P, AsyncResponseContextManager[_AsyncAPIResponseT]]: + """Higher order function that takes one of our bound API methods and an `APIResponse` class + and wraps the method to support streaming and returning the given response class directly. + + Note: the given `response_cls` *must* be concrete, e.g. `class BinaryAPIResponse(APIResponse[bytes])` + """ + + @functools.wraps(func) + def wrapped(*args: P.args, **kwargs: P.kwargs) -> AsyncResponseContextManager[_AsyncAPIResponseT]: + extra_headers: dict[str, Any] = {**(cast(Any, kwargs.get("extra_headers")) or {})} + extra_headers[RAW_RESPONSE_HEADER] = "stream" + extra_headers[OVERRIDE_CAST_TO_HEADER] = response_cls + + kwargs["extra_headers"] = extra_headers + + make_request = func(*args, **kwargs) + + return AsyncResponseContextManager(cast(Awaitable[_AsyncAPIResponseT], make_request)) + + return wrapped + + +def to_raw_response_wrapper(func: Callable[P, R]) -> Callable[P, APIResponse[R]]: + """Higher order function that takes one of our bound API methods and wraps it + to support returning the raw `APIResponse` object directly. + """ + + @functools.wraps(func) + def wrapped(*args: P.args, **kwargs: P.kwargs) -> APIResponse[R]: + extra_headers: dict[str, str] = {**(cast(Any, kwargs.get("extra_headers")) or {})} + extra_headers[RAW_RESPONSE_HEADER] = "raw" + + kwargs["extra_headers"] = extra_headers + + return cast(APIResponse[R], func(*args, **kwargs)) + + return wrapped + + +def async_to_raw_response_wrapper(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[AsyncAPIResponse[R]]]: + """Higher order function that takes one of our bound API methods and wraps it + to support returning the raw `APIResponse` object directly. + """ + + @functools.wraps(func) + async def wrapped(*args: P.args, **kwargs: P.kwargs) -> AsyncAPIResponse[R]: + extra_headers: dict[str, str] = {**(cast(Any, kwargs.get("extra_headers")) or {})} + extra_headers[RAW_RESPONSE_HEADER] = "raw" + + kwargs["extra_headers"] = extra_headers + + return cast(AsyncAPIResponse[R], await func(*args, **kwargs)) + + return wrapped + + +def to_custom_raw_response_wrapper( + func: Callable[P, object], + response_cls: type[_APIResponseT], +) -> Callable[P, _APIResponseT]: + """Higher order function that takes one of our bound API methods and an `APIResponse` class + and wraps the method to support returning the given response class directly. + + Note: the given `response_cls` *must* be concrete, e.g. `class BinaryAPIResponse(APIResponse[bytes])` + """ + + @functools.wraps(func) + def wrapped(*args: P.args, **kwargs: P.kwargs) -> _APIResponseT: + extra_headers: dict[str, Any] = {**(cast(Any, kwargs.get("extra_headers")) or {})} + extra_headers[RAW_RESPONSE_HEADER] = "raw" + extra_headers[OVERRIDE_CAST_TO_HEADER] = response_cls + + kwargs["extra_headers"] = extra_headers + + return cast(_APIResponseT, func(*args, **kwargs)) + + return wrapped + + +def async_to_custom_raw_response_wrapper( + func: Callable[P, Awaitable[object]], + response_cls: type[_AsyncAPIResponseT], +) -> Callable[P, Awaitable[_AsyncAPIResponseT]]: + """Higher order function that takes one of our bound API methods and an `APIResponse` class + and wraps the method to support returning the given response class directly. + + Note: the given `response_cls` *must* be concrete, e.g. `class BinaryAPIResponse(APIResponse[bytes])` + """ + + @functools.wraps(func) + def wrapped(*args: P.args, **kwargs: P.kwargs) -> Awaitable[_AsyncAPIResponseT]: + extra_headers: dict[str, Any] = {**(cast(Any, kwargs.get("extra_headers")) or {})} + extra_headers[RAW_RESPONSE_HEADER] = "raw" + extra_headers[OVERRIDE_CAST_TO_HEADER] = response_cls + + kwargs["extra_headers"] = extra_headers + + return cast(Awaitable[_AsyncAPIResponseT], func(*args, **kwargs)) + + return wrapped + + +def extract_response_type(typ: type[BaseAPIResponse[Any]]) -> type: + """Given a type like `APIResponse[T]`, returns the generic type variable `T`. + + This also handles the case where a concrete subclass is given, e.g. + ```py + class MyResponse(APIResponse[bytes]): + ... + + extract_response_type(MyResponse) -> bytes + ``` + """ + return extract_type_var_from_base( + typ, + generic_bases=cast("tuple[type, ...]", (BaseAPIResponse, APIResponse, AsyncAPIResponse)), + index=0, + ) diff --git a/src/agentex_sdk/_streaming.py b/src/agentex_sdk/_streaming.py new file mode 100644 index 00000000..d44f59f6 --- /dev/null +++ b/src/agentex_sdk/_streaming.py @@ -0,0 +1,333 @@ +# Note: initially copied from https://github.com/florimondmanca/httpx-sse/blob/master/src/httpx_sse/_decoders.py +from __future__ import annotations + +import json +import inspect +from types import TracebackType +from typing import TYPE_CHECKING, Any, Generic, TypeVar, Iterator, AsyncIterator, cast +from typing_extensions import Self, Protocol, TypeGuard, override, get_origin, runtime_checkable + +import httpx + +from ._utils import extract_type_var_from_base + +if TYPE_CHECKING: + from ._client import AgentexSDK, AsyncAgentexSDK + + +_T = TypeVar("_T") + + +class Stream(Generic[_T]): + """Provides the core interface to iterate over a synchronous stream response.""" + + response: httpx.Response + + _decoder: SSEBytesDecoder + + def __init__( + self, + *, + cast_to: type[_T], + response: httpx.Response, + client: AgentexSDK, + ) -> None: + self.response = response + self._cast_to = cast_to + self._client = client + self._decoder = client._make_sse_decoder() + self._iterator = self.__stream__() + + def __next__(self) -> _T: + return self._iterator.__next__() + + def __iter__(self) -> Iterator[_T]: + for item in self._iterator: + yield item + + def _iter_events(self) -> Iterator[ServerSentEvent]: + yield from self._decoder.iter_bytes(self.response.iter_bytes()) + + def __stream__(self) -> Iterator[_T]: + cast_to = cast(Any, self._cast_to) + response = self.response + process_data = self._client._process_response_data + iterator = self._iter_events() + + for sse in iterator: + yield process_data(data=sse.json(), cast_to=cast_to, response=response) + + # Ensure the entire stream is consumed + for _sse in iterator: + ... + + def __enter__(self) -> Self: + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.close() + + def close(self) -> None: + """ + Close the response and release the connection. + + Automatically called if the response body is read to completion. + """ + self.response.close() + + +class AsyncStream(Generic[_T]): + """Provides the core interface to iterate over an asynchronous stream response.""" + + response: httpx.Response + + _decoder: SSEDecoder | SSEBytesDecoder + + def __init__( + self, + *, + cast_to: type[_T], + response: httpx.Response, + client: AsyncAgentexSDK, + ) -> None: + self.response = response + self._cast_to = cast_to + self._client = client + self._decoder = client._make_sse_decoder() + self._iterator = self.__stream__() + + async def __anext__(self) -> _T: + return await self._iterator.__anext__() + + async def __aiter__(self) -> AsyncIterator[_T]: + async for item in self._iterator: + yield item + + async def _iter_events(self) -> AsyncIterator[ServerSentEvent]: + async for sse in self._decoder.aiter_bytes(self.response.aiter_bytes()): + yield sse + + async def __stream__(self) -> AsyncIterator[_T]: + cast_to = cast(Any, self._cast_to) + response = self.response + process_data = self._client._process_response_data + iterator = self._iter_events() + + async for sse in iterator: + yield process_data(data=sse.json(), cast_to=cast_to, response=response) + + # Ensure the entire stream is consumed + async for _sse in iterator: + ... + + async def __aenter__(self) -> Self: + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + await self.close() + + async def close(self) -> None: + """ + Close the response and release the connection. + + Automatically called if the response body is read to completion. + """ + await self.response.aclose() + + +class ServerSentEvent: + def __init__( + self, + *, + event: str | None = None, + data: str | None = None, + id: str | None = None, + retry: int | None = None, + ) -> None: + if data is None: + data = "" + + self._id = id + self._data = data + self._event = event or None + self._retry = retry + + @property + def event(self) -> str | None: + return self._event + + @property + def id(self) -> str | None: + return self._id + + @property + def retry(self) -> int | None: + return self._retry + + @property + def data(self) -> str: + return self._data + + def json(self) -> Any: + return json.loads(self.data) + + @override + def __repr__(self) -> str: + return f"ServerSentEvent(event={self.event}, data={self.data}, id={self.id}, retry={self.retry})" + + +class SSEDecoder: + _data: list[str] + _event: str | None + _retry: int | None + _last_event_id: str | None + + def __init__(self) -> None: + self._event = None + self._data = [] + self._last_event_id = None + self._retry = None + + def iter_bytes(self, iterator: Iterator[bytes]) -> Iterator[ServerSentEvent]: + """Given an iterator that yields raw binary data, iterate over it & yield every event encountered""" + for chunk in self._iter_chunks(iterator): + # Split before decoding so splitlines() only uses \r and \n + for raw_line in chunk.splitlines(): + line = raw_line.decode("utf-8") + sse = self.decode(line) + if sse: + yield sse + + def _iter_chunks(self, iterator: Iterator[bytes]) -> Iterator[bytes]: + """Given an iterator that yields raw binary data, iterate over it and yield individual SSE chunks""" + data = b"" + for chunk in iterator: + for line in chunk.splitlines(keepends=True): + data += line + if data.endswith((b"\r\r", b"\n\n", b"\r\n\r\n")): + yield data + data = b"" + if data: + yield data + + async def aiter_bytes(self, iterator: AsyncIterator[bytes]) -> AsyncIterator[ServerSentEvent]: + """Given an iterator that yields raw binary data, iterate over it & yield every event encountered""" + async for chunk in self._aiter_chunks(iterator): + # Split before decoding so splitlines() only uses \r and \n + for raw_line in chunk.splitlines(): + line = raw_line.decode("utf-8") + sse = self.decode(line) + if sse: + yield sse + + async def _aiter_chunks(self, iterator: AsyncIterator[bytes]) -> AsyncIterator[bytes]: + """Given an iterator that yields raw binary data, iterate over it and yield individual SSE chunks""" + data = b"" + async for chunk in iterator: + for line in chunk.splitlines(keepends=True): + data += line + if data.endswith((b"\r\r", b"\n\n", b"\r\n\r\n")): + yield data + data = b"" + if data: + yield data + + def decode(self, line: str) -> ServerSentEvent | None: + # See: https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation # noqa: E501 + + if not line: + if not self._event and not self._data and not self._last_event_id and self._retry is None: + return None + + sse = ServerSentEvent( + event=self._event, + data="\n".join(self._data), + id=self._last_event_id, + retry=self._retry, + ) + + # NOTE: as per the SSE spec, do not reset last_event_id. + self._event = None + self._data = [] + self._retry = None + + return sse + + if line.startswith(":"): + return None + + fieldname, _, value = line.partition(":") + + if value.startswith(" "): + value = value[1:] + + if fieldname == "event": + self._event = value + elif fieldname == "data": + self._data.append(value) + elif fieldname == "id": + if "\0" in value: + pass + else: + self._last_event_id = value + elif fieldname == "retry": + try: + self._retry = int(value) + except (TypeError, ValueError): + pass + else: + pass # Field is ignored. + + return None + + +@runtime_checkable +class SSEBytesDecoder(Protocol): + def iter_bytes(self, iterator: Iterator[bytes]) -> Iterator[ServerSentEvent]: + """Given an iterator that yields raw binary data, iterate over it & yield every event encountered""" + ... + + def aiter_bytes(self, iterator: AsyncIterator[bytes]) -> AsyncIterator[ServerSentEvent]: + """Given an async iterator that yields raw binary data, iterate over it & yield every event encountered""" + ... + + +def is_stream_class_type(typ: type) -> TypeGuard[type[Stream[object]] | type[AsyncStream[object]]]: + """TypeGuard for determining whether or not the given type is a subclass of `Stream` / `AsyncStream`""" + origin = get_origin(typ) or typ + return inspect.isclass(origin) and issubclass(origin, (Stream, AsyncStream)) + + +def extract_stream_chunk_type( + stream_cls: type, + *, + failure_message: str | None = None, +) -> type: + """Given a type like `Stream[T]`, returns the generic type variable `T`. + + This also handles the case where a concrete subclass is given, e.g. + ```py + class MyStream(Stream[bytes]): + ... + + extract_stream_chunk_type(MyStream) -> bytes + ``` + """ + from ._base_client import Stream, AsyncStream + + return extract_type_var_from_base( + stream_cls, + index=0, + generic_bases=cast("tuple[type, ...]", (Stream, AsyncStream)), + failure_message=failure_message, + ) diff --git a/src/agentex_sdk/_types.py b/src/agentex_sdk/_types.py new file mode 100644 index 00000000..187b412b --- /dev/null +++ b/src/agentex_sdk/_types.py @@ -0,0 +1,219 @@ +from __future__ import annotations + +from os import PathLike +from typing import ( + IO, + TYPE_CHECKING, + Any, + Dict, + List, + Type, + Tuple, + Union, + Mapping, + TypeVar, + Callable, + Optional, + Sequence, +) +from typing_extensions import Set, Literal, Protocol, TypeAlias, TypedDict, override, runtime_checkable + +import httpx +import pydantic +from httpx import URL, Proxy, Timeout, Response, BaseTransport, AsyncBaseTransport + +if TYPE_CHECKING: + from ._models import BaseModel + from ._response import APIResponse, AsyncAPIResponse + +Transport = BaseTransport +AsyncTransport = AsyncBaseTransport +Query = Mapping[str, object] +Body = object +AnyMapping = Mapping[str, object] +ModelT = TypeVar("ModelT", bound=pydantic.BaseModel) +_T = TypeVar("_T") + + +# Approximates httpx internal ProxiesTypes and RequestFiles types +# while adding support for `PathLike` instances +ProxiesDict = Dict["str | URL", Union[None, str, URL, Proxy]] +ProxiesTypes = Union[str, Proxy, ProxiesDict] +if TYPE_CHECKING: + Base64FileInput = Union[IO[bytes], PathLike[str]] + FileContent = Union[IO[bytes], bytes, PathLike[str]] +else: + Base64FileInput = Union[IO[bytes], PathLike] + FileContent = Union[IO[bytes], bytes, PathLike] # PathLike is not subscriptable in Python 3.8. +FileTypes = Union[ + # file (or bytes) + FileContent, + # (filename, file (or bytes)) + Tuple[Optional[str], FileContent], + # (filename, file (or bytes), content_type) + Tuple[Optional[str], FileContent, Optional[str]], + # (filename, file (or bytes), content_type, headers) + Tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]], +] +RequestFiles = Union[Mapping[str, FileTypes], Sequence[Tuple[str, FileTypes]]] + +# duplicate of the above but without our custom file support +HttpxFileContent = Union[IO[bytes], bytes] +HttpxFileTypes = Union[ + # file (or bytes) + HttpxFileContent, + # (filename, file (or bytes)) + Tuple[Optional[str], HttpxFileContent], + # (filename, file (or bytes), content_type) + Tuple[Optional[str], HttpxFileContent, Optional[str]], + # (filename, file (or bytes), content_type, headers) + Tuple[Optional[str], HttpxFileContent, Optional[str], Mapping[str, str]], +] +HttpxRequestFiles = Union[Mapping[str, HttpxFileTypes], Sequence[Tuple[str, HttpxFileTypes]]] + +# Workaround to support (cast_to: Type[ResponseT]) -> ResponseT +# where ResponseT includes `None`. In order to support directly +# passing `None`, overloads would have to be defined for every +# method that uses `ResponseT` which would lead to an unacceptable +# amount of code duplication and make it unreadable. See _base_client.py +# for example usage. +# +# This unfortunately means that you will either have +# to import this type and pass it explicitly: +# +# from agentex_sdk import NoneType +# client.get('/foo', cast_to=NoneType) +# +# or build it yourself: +# +# client.get('/foo', cast_to=type(None)) +if TYPE_CHECKING: + NoneType: Type[None] +else: + NoneType = type(None) + + +class RequestOptions(TypedDict, total=False): + headers: Headers + max_retries: int + timeout: float | Timeout | None + params: Query + extra_json: AnyMapping + idempotency_key: str + follow_redirects: bool + + +# Sentinel class used until PEP 0661 is accepted +class NotGiven: + """ + A sentinel singleton class used to distinguish omitted keyword arguments + from those passed in with the value None (which may have different behavior). + + For example: + + ```py + def get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: ... + + + get(timeout=1) # 1s timeout + get(timeout=None) # No timeout + get() # Default timeout behavior, which may not be statically known at the method definition. + ``` + """ + + def __bool__(self) -> Literal[False]: + return False + + @override + def __repr__(self) -> str: + return "NOT_GIVEN" + + +NotGivenOr = Union[_T, NotGiven] +NOT_GIVEN = NotGiven() + + +class Omit: + """In certain situations you need to be able to represent a case where a default value has + to be explicitly removed and `None` is not an appropriate substitute, for example: + + ```py + # as the default `Content-Type` header is `application/json` that will be sent + client.post("/upload/files", files={"file": b"my raw file content"}) + + # you can't explicitly override the header as it has to be dynamically generated + # to look something like: 'multipart/form-data; boundary=0d8382fcf5f8c3be01ca2e11002d2983' + client.post(..., headers={"Content-Type": "multipart/form-data"}) + + # instead you can remove the default `application/json` header by passing Omit + client.post(..., headers={"Content-Type": Omit()}) + ``` + """ + + def __bool__(self) -> Literal[False]: + return False + + +@runtime_checkable +class ModelBuilderProtocol(Protocol): + @classmethod + def build( + cls: type[_T], + *, + response: Response, + data: object, + ) -> _T: ... + + +Headers = Mapping[str, Union[str, Omit]] + + +class HeadersLikeProtocol(Protocol): + def get(self, __key: str) -> str | None: ... + + +HeadersLike = Union[Headers, HeadersLikeProtocol] + +ResponseT = TypeVar( + "ResponseT", + bound=Union[ + object, + str, + None, + "BaseModel", + List[Any], + Dict[str, Any], + Response, + ModelBuilderProtocol, + "APIResponse[Any]", + "AsyncAPIResponse[Any]", + ], +) + +StrBytesIntFloat = Union[str, bytes, int, float] + +# Note: copied from Pydantic +# https://github.com/pydantic/pydantic/blob/6f31f8f68ef011f84357330186f603ff295312fd/pydantic/main.py#L79 +IncEx: TypeAlias = Union[Set[int], Set[str], Mapping[int, Union["IncEx", bool]], Mapping[str, Union["IncEx", bool]]] + +PostParser = Callable[[Any], Any] + + +@runtime_checkable +class InheritsGeneric(Protocol): + """Represents a type that has inherited from `Generic` + + The `__orig_bases__` property can be used to determine the resolved + type variable for a given base class. + """ + + __orig_bases__: tuple[_GenericAlias] + + +class _GenericAlias(Protocol): + __origin__: type[object] + + +class HttpxSendArgs(TypedDict, total=False): + auth: httpx.Auth + follow_redirects: bool diff --git a/src/agentex_sdk/_utils/__init__.py b/src/agentex_sdk/_utils/__init__.py new file mode 100644 index 00000000..d4fda26f --- /dev/null +++ b/src/agentex_sdk/_utils/__init__.py @@ -0,0 +1,57 @@ +from ._sync import asyncify as asyncify +from ._proxy import LazyProxy as LazyProxy +from ._utils import ( + flatten as flatten, + is_dict as is_dict, + is_list as is_list, + is_given as is_given, + is_tuple as is_tuple, + json_safe as json_safe, + lru_cache as lru_cache, + is_mapping as is_mapping, + is_tuple_t as is_tuple_t, + parse_date as parse_date, + is_iterable as is_iterable, + is_sequence as is_sequence, + coerce_float as coerce_float, + is_mapping_t as is_mapping_t, + removeprefix as removeprefix, + removesuffix as removesuffix, + extract_files as extract_files, + is_sequence_t as is_sequence_t, + required_args as required_args, + coerce_boolean as coerce_boolean, + coerce_integer as coerce_integer, + file_from_path as file_from_path, + parse_datetime as parse_datetime, + strip_not_given as strip_not_given, + deepcopy_minimal as deepcopy_minimal, + get_async_library as get_async_library, + maybe_coerce_float as maybe_coerce_float, + get_required_header as get_required_header, + maybe_coerce_boolean as maybe_coerce_boolean, + maybe_coerce_integer as maybe_coerce_integer, +) +from ._typing import ( + is_list_type as is_list_type, + is_union_type as is_union_type, + extract_type_arg as extract_type_arg, + is_iterable_type as is_iterable_type, + is_required_type as is_required_type, + is_annotated_type as is_annotated_type, + is_type_alias_type as is_type_alias_type, + strip_annotated_type as strip_annotated_type, + extract_type_var_from_base as extract_type_var_from_base, +) +from ._streams import consume_sync_iterator as consume_sync_iterator, consume_async_iterator as consume_async_iterator +from ._transform import ( + PropertyInfo as PropertyInfo, + transform as transform, + async_transform as async_transform, + maybe_transform as maybe_transform, + async_maybe_transform as async_maybe_transform, +) +from ._reflection import ( + function_has_argument as function_has_argument, + assert_signatures_in_sync as assert_signatures_in_sync, +) diff --git a/src/agentex_sdk/_utils/_logs.py b/src/agentex_sdk/_utils/_logs.py new file mode 100644 index 00000000..d94b1704 --- /dev/null +++ b/src/agentex_sdk/_utils/_logs.py @@ -0,0 +1,25 @@ +import os +import logging + +logger: logging.Logger = logging.getLogger("agentex_sdk") +httpx_logger: logging.Logger = logging.getLogger("httpx") + + +def _basic_config() -> None: + # e.g. [2023-10-05 14:12:26 - agentex_sdk._base_client:818 - DEBUG] HTTP Request: POST http://127.0.0.1:4010/foo/bar "200 OK" + logging.basicConfig( + format="[%(asctime)s - %(name)s:%(lineno)d - %(levelname)s] %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + ) + + +def setup_logging() -> None: + env = os.environ.get("AGENTEX_SDK_LOG") + if env == "debug": + _basic_config() + logger.setLevel(logging.DEBUG) + httpx_logger.setLevel(logging.DEBUG) + elif env == "info": + _basic_config() + logger.setLevel(logging.INFO) + httpx_logger.setLevel(logging.INFO) diff --git a/src/agentex_sdk/_utils/_proxy.py b/src/agentex_sdk/_utils/_proxy.py new file mode 100644 index 00000000..0f239a33 --- /dev/null +++ b/src/agentex_sdk/_utils/_proxy.py @@ -0,0 +1,65 @@ +from __future__ import annotations + +from abc import ABC, abstractmethod +from typing import Generic, TypeVar, Iterable, cast +from typing_extensions import override + +T = TypeVar("T") + + +class LazyProxy(Generic[T], ABC): + """Implements data methods to pretend that an instance is another instance. + + This includes forwarding attribute access and other methods. + """ + + # Note: we have to special case proxies that themselves return proxies + # to support using a proxy as a catch-all for any random access, e.g. `proxy.foo.bar.baz` + + def __getattr__(self, attr: str) -> object: + proxied = self.__get_proxied__() + if isinstance(proxied, LazyProxy): + return proxied # pyright: ignore + return getattr(proxied, attr) + + @override + def __repr__(self) -> str: + proxied = self.__get_proxied__() + if isinstance(proxied, LazyProxy): + return proxied.__class__.__name__ + return repr(self.__get_proxied__()) + + @override + def __str__(self) -> str: + proxied = self.__get_proxied__() + if isinstance(proxied, LazyProxy): + return proxied.__class__.__name__ + return str(proxied) + + @override + def __dir__(self) -> Iterable[str]: + proxied = self.__get_proxied__() + if isinstance(proxied, LazyProxy): + return [] + return proxied.__dir__() + + @property # type: ignore + @override + def __class__(self) -> type: # pyright: ignore + try: + proxied = self.__get_proxied__() + except Exception: + return type(self) + if issubclass(type(proxied), LazyProxy): + return type(proxied) + return proxied.__class__ + + def __get_proxied__(self) -> T: + return self.__load__() + + def __as_proxied__(self) -> T: + """Helper method that returns the current proxy, typed as the loaded object""" + return cast(T, self) + + @abstractmethod + def __load__(self) -> T: ... diff --git a/src/agentex_sdk/_utils/_reflection.py b/src/agentex_sdk/_utils/_reflection.py new file mode 100644 index 00000000..89aa712a --- /dev/null +++ b/src/agentex_sdk/_utils/_reflection.py @@ -0,0 +1,42 @@ +from __future__ import annotations + +import inspect +from typing import Any, Callable + + +def function_has_argument(func: Callable[..., Any], arg_name: str) -> bool: + """Returns whether or not the given function has a specific parameter""" + sig = inspect.signature(func) + return arg_name in sig.parameters + + +def assert_signatures_in_sync( + source_func: Callable[..., Any], + check_func: Callable[..., Any], + *, + exclude_params: set[str] = set(), +) -> None: + """Ensure that the signature of the second function matches the first.""" + + check_sig = inspect.signature(check_func) + source_sig = inspect.signature(source_func) + + errors: list[str] = [] + + for name, source_param in source_sig.parameters.items(): + if name in exclude_params: + continue + + custom_param = check_sig.parameters.get(name) + if not custom_param: + errors.append(f"the `{name}` param is missing") + continue + + if custom_param.annotation != source_param.annotation: + errors.append( + f"types for the `{name}` param are do not match; source={repr(source_param.annotation)} checking={repr(custom_param.annotation)}" + ) + continue + + if errors: + raise AssertionError(f"{len(errors)} errors encountered when comparing signatures:\n\n" + "\n\n".join(errors)) diff --git a/src/agentex_sdk/_utils/_resources_proxy.py b/src/agentex_sdk/_utils/_resources_proxy.py new file mode 100644 index 00000000..2cc2f9db --- /dev/null +++ b/src/agentex_sdk/_utils/_resources_proxy.py @@ -0,0 +1,24 @@ +from __future__ import annotations + +from typing import Any +from typing_extensions import override + +from ._proxy import LazyProxy + + +class ResourcesProxy(LazyProxy[Any]): + """A proxy for the `agentex_sdk.resources` module. + + This is used so that we can lazily import `agentex_sdk.resources` only when + needed *and* so that users can just import `agentex_sdk` and reference `agentex_sdk.resources` + """ + + @override + def __load__(self) -> Any: + import importlib + + mod = importlib.import_module("agentex_sdk.resources") + return mod + + +resources = ResourcesProxy().__as_proxied__() diff --git a/src/agentex_sdk/_utils/_streams.py b/src/agentex_sdk/_utils/_streams.py new file mode 100644 index 00000000..f4a0208f --- /dev/null +++ b/src/agentex_sdk/_utils/_streams.py @@ -0,0 +1,12 @@ +from typing import Any +from typing_extensions import Iterator, AsyncIterator + + +def consume_sync_iterator(iterator: Iterator[Any]) -> None: + for _ in iterator: + ... + + +async def consume_async_iterator(iterator: AsyncIterator[Any]) -> None: + async for _ in iterator: + ... diff --git a/src/agentex_sdk/_utils/_sync.py b/src/agentex_sdk/_utils/_sync.py new file mode 100644 index 00000000..ad7ec71b --- /dev/null +++ b/src/agentex_sdk/_utils/_sync.py @@ -0,0 +1,86 @@ +from __future__ import annotations + +import sys +import asyncio +import functools +import contextvars +from typing import Any, TypeVar, Callable, Awaitable +from typing_extensions import ParamSpec + +import anyio +import sniffio +import anyio.to_thread + +T_Retval = TypeVar("T_Retval") +T_ParamSpec = ParamSpec("T_ParamSpec") + + +if sys.version_info >= (3, 9): + _asyncio_to_thread = asyncio.to_thread +else: + # backport of https://docs.python.org/3/library/asyncio-task.html#asyncio.to_thread + # for Python 3.8 support + async def _asyncio_to_thread( + func: Callable[T_ParamSpec, T_Retval], /, *args: T_ParamSpec.args, **kwargs: T_ParamSpec.kwargs + ) -> Any: + """Asynchronously run function *func* in a separate thread. + + Any *args and **kwargs supplied for this function are directly passed + to *func*. Also, the current :class:`contextvars.Context` is propagated, + allowing context variables from the main thread to be accessed in the + separate thread. + + Returns a coroutine that can be awaited to get the eventual result of *func*. + """ + loop = asyncio.events.get_running_loop() + ctx = contextvars.copy_context() + func_call = functools.partial(ctx.run, func, *args, **kwargs) + return await loop.run_in_executor(None, func_call) + + +async def to_thread( + func: Callable[T_ParamSpec, T_Retval], /, *args: T_ParamSpec.args, **kwargs: T_ParamSpec.kwargs +) -> T_Retval: + if sniffio.current_async_library() == "asyncio": + return await _asyncio_to_thread(func, *args, **kwargs) + + return await anyio.to_thread.run_sync( + functools.partial(func, *args, **kwargs), + ) + + +# inspired by `asyncer`, https://github.com/tiangolo/asyncer +def asyncify(function: Callable[T_ParamSpec, T_Retval]) -> Callable[T_ParamSpec, Awaitable[T_Retval]]: + """ + Take a blocking function and create an async one that receives the same + positional and keyword arguments. For python version 3.9 and above, it uses + asyncio.to_thread to run the function in a separate thread. For python version + 3.8, it uses locally defined copy of the asyncio.to_thread function which was + introduced in python 3.9. + + Usage: + + ```python + def blocking_func(arg1, arg2, kwarg1=None): + # blocking code + return result + + + result = asyncify(blocking_function)(arg1, arg2, kwarg1=value1) + ``` + + ## Arguments + + `function`: a blocking regular callable (e.g. a function) + + ## Return + + An async function that takes the same positional and keyword arguments as the + original one, that when called runs the same original function in a thread worker + and returns the result. + """ + + async def wrapper(*args: T_ParamSpec.args, **kwargs: T_ParamSpec.kwargs) -> T_Retval: + return await to_thread(function, *args, **kwargs) + + return wrapper diff --git a/src/agentex_sdk/_utils/_transform.py b/src/agentex_sdk/_utils/_transform.py new file mode 100644 index 00000000..b0cc20a7 --- /dev/null +++ b/src/agentex_sdk/_utils/_transform.py @@ -0,0 +1,447 @@ +from __future__ import annotations + +import io +import base64 +import pathlib +from typing import Any, Mapping, TypeVar, cast +from datetime import date, datetime +from typing_extensions import Literal, get_args, override, get_type_hints as _get_type_hints + +import anyio +import pydantic + +from ._utils import ( + is_list, + is_given, + lru_cache, + is_mapping, + is_iterable, +) +from .._files import is_base64_file_input +from ._typing import ( + is_list_type, + is_union_type, + extract_type_arg, + is_iterable_type, + is_required_type, + is_annotated_type, + strip_annotated_type, +) +from .._compat import get_origin, model_dump, is_typeddict + +_T = TypeVar("_T") + + +# TODO: support for drilling globals() and locals() +# TODO: ensure works correctly with forward references in all cases + + +PropertyFormat = Literal["iso8601", "base64", "custom"] + + +class PropertyInfo: + """Metadata class to be used in Annotated types to provide information about a given type. + + For example: + + class MyParams(TypedDict): + account_holder_name: Annotated[str, PropertyInfo(alias='accountHolderName')] + + This means that {'account_holder_name': 'Robert'} will be transformed to {'accountHolderName': 'Robert'} before being sent to the API. + """ + + alias: str | None + format: PropertyFormat | None + format_template: str | None + discriminator: str | None + + def __init__( + self, + *, + alias: str | None = None, + format: PropertyFormat | None = None, + format_template: str | None = None, + discriminator: str | None = None, + ) -> None: + self.alias = alias + self.format = format + self.format_template = format_template + self.discriminator = discriminator + + @override + def __repr__(self) -> str: + return f"{self.__class__.__name__}(alias='{self.alias}', format={self.format}, format_template='{self.format_template}', discriminator='{self.discriminator}')" + + +def maybe_transform( + data: object, + expected_type: object, +) -> Any | None: + """Wrapper over `transform()` that allows `None` to be passed. + + See `transform()` for more details. + """ + if data is None: + return None + return transform(data, expected_type) + + +# Wrapper over _transform_recursive providing fake types +def transform( + data: _T, + expected_type: object, +) -> _T: + """Transform dictionaries based off of type information from the given type, for example: + + ```py + class Params(TypedDict, total=False): + card_id: Required[Annotated[str, PropertyInfo(alias="cardID")]] + + + transformed = transform({"card_id": ""}, Params) + # {'cardID': ''} + ``` + + Any keys / data that does not have type information given will be included as is. + + It should be noted that the transformations that this function does are not represented in the type system. + """ + transformed = _transform_recursive(data, annotation=cast(type, expected_type)) + return cast(_T, transformed) + + +@lru_cache(maxsize=8096) +def _get_annotated_type(type_: type) -> type | None: + """If the given type is an `Annotated` type then it is returned, if not `None` is returned. + + This also unwraps the type when applicable, e.g. `Required[Annotated[T, ...]]` + """ + if is_required_type(type_): + # Unwrap `Required[Annotated[T, ...]]` to `Annotated[T, ...]` + type_ = get_args(type_)[0] + + if is_annotated_type(type_): + return type_ + + return None + + +def _maybe_transform_key(key: str, type_: type) -> str: + """Transform the given `data` based on the annotations provided in `type_`. + + Note: this function only looks at `Annotated` types that contain `PropertyInfo` metadata. + """ + annotated_type = _get_annotated_type(type_) + if annotated_type is None: + # no `Annotated` definition for this type, no transformation needed + return key + + # ignore the first argument as it is the actual type + annotations = get_args(annotated_type)[1:] + for annotation in annotations: + if isinstance(annotation, PropertyInfo) and annotation.alias is not None: + return annotation.alias + + return key + + +def _no_transform_needed(annotation: type) -> bool: + return annotation == float or annotation == int + + +def _transform_recursive( + data: object, + *, + annotation: type, + inner_type: type | None = None, +) -> object: + """Transform the given data against the expected type. + + Args: + annotation: The direct type annotation given to the particular piece of data. + This may or may not be wrapped in metadata types, e.g. `Required[T]`, `Annotated[T, ...]` etc + + inner_type: If applicable, this is the "inside" type. This is useful in certain cases where the outside type + is a container type such as `List[T]`. In that case `inner_type` should be set to `T` so that each entry in + the list can be transformed using the metadata from the container type. + + Defaults to the same value as the `annotation` argument. + """ + if inner_type is None: + inner_type = annotation + + stripped_type = strip_annotated_type(inner_type) + origin = get_origin(stripped_type) or stripped_type + if is_typeddict(stripped_type) and is_mapping(data): + return _transform_typeddict(data, stripped_type) + + if origin == dict and is_mapping(data): + items_type = get_args(stripped_type)[1] + return {key: _transform_recursive(value, annotation=items_type) for key, value in data.items()} + + if ( + # List[T] + (is_list_type(stripped_type) and is_list(data)) + # Iterable[T] + or (is_iterable_type(stripped_type) and is_iterable(data) and not isinstance(data, str)) + ): + # dicts are technically iterable, but it is an iterable on the keys of the dict and is not usually + # intended as an iterable, so we don't transform it. + if isinstance(data, dict): + return cast(object, data) + + inner_type = extract_type_arg(stripped_type, 0) + if _no_transform_needed(inner_type): + # for some types there is no need to transform anything, so we can get a small + # perf boost from skipping that work. + # + # but we still need to convert to a list to ensure the data is json-serializable + if is_list(data): + return data + return list(data) + + return [_transform_recursive(d, annotation=annotation, inner_type=inner_type) for d in data] + + if is_union_type(stripped_type): + # For union types we run the transformation against all subtypes to ensure that everything is transformed. + # + # TODO: there may be edge cases where the same normalized field name will transform to two different names + # in different subtypes. + for subtype in get_args(stripped_type): + data = _transform_recursive(data, annotation=annotation, inner_type=subtype) + return data + + if isinstance(data, pydantic.BaseModel): + return model_dump(data, exclude_unset=True, mode="json") + + annotated_type = _get_annotated_type(annotation) + if annotated_type is None: + return data + + # ignore the first argument as it is the actual type + annotations = get_args(annotated_type)[1:] + for annotation in annotations: + if isinstance(annotation, PropertyInfo) and annotation.format is not None: + return _format_data(data, annotation.format, annotation.format_template) + + return data + + +def _format_data(data: object, format_: PropertyFormat, format_template: str | None) -> object: + if isinstance(data, (date, datetime)): + if format_ == "iso8601": + return data.isoformat() + + if format_ == "custom" and format_template is not None: + return data.strftime(format_template) + + if format_ == "base64" and is_base64_file_input(data): + binary: str | bytes | None = None + + if isinstance(data, pathlib.Path): + binary = data.read_bytes() + elif isinstance(data, io.IOBase): + binary = data.read() + + if isinstance(binary, str): # type: ignore[unreachable] + binary = binary.encode() + + if not isinstance(binary, bytes): + raise RuntimeError(f"Could not read bytes from {data}; Received {type(binary)}") + + return base64.b64encode(binary).decode("ascii") + + return data + + +def _transform_typeddict( + data: Mapping[str, object], + expected_type: type, +) -> Mapping[str, object]: + result: dict[str, object] = {} + annotations = get_type_hints(expected_type, include_extras=True) + for key, value in data.items(): + if not is_given(value): + # we don't need to include `NotGiven` values here as they'll + # be stripped out before the request is sent anyway + continue + + type_ = annotations.get(key) + if type_ is None: + # we do not have a type annotation for this field, leave it as is + result[key] = value + else: + result[_maybe_transform_key(key, type_)] = _transform_recursive(value, annotation=type_) + return result + + +async def async_maybe_transform( + data: object, + expected_type: object, +) -> Any | None: + """Wrapper over `async_transform()` that allows `None` to be passed. + + See `async_transform()` for more details. + """ + if data is None: + return None + return await async_transform(data, expected_type) + + +async def async_transform( + data: _T, + expected_type: object, +) -> _T: + """Transform dictionaries based off of type information from the given type, for example: + + ```py + class Params(TypedDict, total=False): + card_id: Required[Annotated[str, PropertyInfo(alias="cardID")]] + + + transformed = transform({"card_id": ""}, Params) + # {'cardID': ''} + ``` + + Any keys / data that does not have type information given will be included as is. + + It should be noted that the transformations that this function does are not represented in the type system. + """ + transformed = await _async_transform_recursive(data, annotation=cast(type, expected_type)) + return cast(_T, transformed) + + +async def _async_transform_recursive( + data: object, + *, + annotation: type, + inner_type: type | None = None, +) -> object: + """Transform the given data against the expected type. + + Args: + annotation: The direct type annotation given to the particular piece of data. + This may or may not be wrapped in metadata types, e.g. `Required[T]`, `Annotated[T, ...]` etc + + inner_type: If applicable, this is the "inside" type. This is useful in certain cases where the outside type + is a container type such as `List[T]`. In that case `inner_type` should be set to `T` so that each entry in + the list can be transformed using the metadata from the container type. + + Defaults to the same value as the `annotation` argument. + """ + if inner_type is None: + inner_type = annotation + + stripped_type = strip_annotated_type(inner_type) + origin = get_origin(stripped_type) or stripped_type + if is_typeddict(stripped_type) and is_mapping(data): + return await _async_transform_typeddict(data, stripped_type) + + if origin == dict and is_mapping(data): + items_type = get_args(stripped_type)[1] + return {key: _transform_recursive(value, annotation=items_type) for key, value in data.items()} + + if ( + # List[T] + (is_list_type(stripped_type) and is_list(data)) + # Iterable[T] + or (is_iterable_type(stripped_type) and is_iterable(data) and not isinstance(data, str)) + ): + # dicts are technically iterable, but it is an iterable on the keys of the dict and is not usually + # intended as an iterable, so we don't transform it. + if isinstance(data, dict): + return cast(object, data) + + inner_type = extract_type_arg(stripped_type, 0) + if _no_transform_needed(inner_type): + # for some types there is no need to transform anything, so we can get a small + # perf boost from skipping that work. + # + # but we still need to convert to a list to ensure the data is json-serializable + if is_list(data): + return data + return list(data) + + return [await _async_transform_recursive(d, annotation=annotation, inner_type=inner_type) for d in data] + + if is_union_type(stripped_type): + # For union types we run the transformation against all subtypes to ensure that everything is transformed. + # + # TODO: there may be edge cases where the same normalized field name will transform to two different names + # in different subtypes. + for subtype in get_args(stripped_type): + data = await _async_transform_recursive(data, annotation=annotation, inner_type=subtype) + return data + + if isinstance(data, pydantic.BaseModel): + return model_dump(data, exclude_unset=True, mode="json") + + annotated_type = _get_annotated_type(annotation) + if annotated_type is None: + return data + + # ignore the first argument as it is the actual type + annotations = get_args(annotated_type)[1:] + for annotation in annotations: + if isinstance(annotation, PropertyInfo) and annotation.format is not None: + return await _async_format_data(data, annotation.format, annotation.format_template) + + return data + + +async def _async_format_data(data: object, format_: PropertyFormat, format_template: str | None) -> object: + if isinstance(data, (date, datetime)): + if format_ == "iso8601": + return data.isoformat() + + if format_ == "custom" and format_template is not None: + return data.strftime(format_template) + + if format_ == "base64" and is_base64_file_input(data): + binary: str | bytes | None = None + + if isinstance(data, pathlib.Path): + binary = await anyio.Path(data).read_bytes() + elif isinstance(data, io.IOBase): + binary = data.read() + + if isinstance(binary, str): # type: ignore[unreachable] + binary = binary.encode() + + if not isinstance(binary, bytes): + raise RuntimeError(f"Could not read bytes from {data}; Received {type(binary)}") + + return base64.b64encode(binary).decode("ascii") + + return data + + +async def _async_transform_typeddict( + data: Mapping[str, object], + expected_type: type, +) -> Mapping[str, object]: + result: dict[str, object] = {} + annotations = get_type_hints(expected_type, include_extras=True) + for key, value in data.items(): + if not is_given(value): + # we don't need to include `NotGiven` values here as they'll + # be stripped out before the request is sent anyway + continue + + type_ = annotations.get(key) + if type_ is None: + # we do not have a type annotation for this field, leave it as is + result[key] = value + else: + result[_maybe_transform_key(key, type_)] = await _async_transform_recursive(value, annotation=type_) + return result + + +@lru_cache(maxsize=8096) +def get_type_hints( + obj: Any, + globalns: dict[str, Any] | None = None, + localns: Mapping[str, Any] | None = None, + include_extras: bool = False, +) -> dict[str, Any]: + return _get_type_hints(obj, globalns=globalns, localns=localns, include_extras=include_extras) diff --git a/src/agentex_sdk/_utils/_typing.py b/src/agentex_sdk/_utils/_typing.py new file mode 100644 index 00000000..1bac9542 --- /dev/null +++ b/src/agentex_sdk/_utils/_typing.py @@ -0,0 +1,151 @@ +from __future__ import annotations + +import sys +import typing +import typing_extensions +from typing import Any, TypeVar, Iterable, cast +from collections import abc as _c_abc +from typing_extensions import ( + TypeIs, + Required, + Annotated, + get_args, + get_origin, +) + +from ._utils import lru_cache +from .._types import InheritsGeneric +from .._compat import is_union as _is_union + + +def is_annotated_type(typ: type) -> bool: + return get_origin(typ) == Annotated + + +def is_list_type(typ: type) -> bool: + return (get_origin(typ) or typ) == list + + +def is_iterable_type(typ: type) -> bool: + """If the given type is `typing.Iterable[T]`""" + origin = get_origin(typ) or typ + return origin == Iterable or origin == _c_abc.Iterable + + +def is_union_type(typ: type) -> bool: + return _is_union(get_origin(typ)) + + +def is_required_type(typ: type) -> bool: + return get_origin(typ) == Required + + +def is_typevar(typ: type) -> bool: + # type ignore is required because type checkers + # think this expression will always return False + return type(typ) == TypeVar # type: ignore + + +_TYPE_ALIAS_TYPES: tuple[type[typing_extensions.TypeAliasType], ...] = (typing_extensions.TypeAliasType,) +if sys.version_info >= (3, 12): + _TYPE_ALIAS_TYPES = (*_TYPE_ALIAS_TYPES, typing.TypeAliasType) + + +def is_type_alias_type(tp: Any, /) -> TypeIs[typing_extensions.TypeAliasType]: + """Return whether the provided argument is an instance of `TypeAliasType`. + + ```python + type Int = int + is_type_alias_type(Int) + # > True + Str = TypeAliasType("Str", str) + is_type_alias_type(Str) + # > True + ``` + """ + return isinstance(tp, _TYPE_ALIAS_TYPES) + + +# Extracts T from Annotated[T, ...] or from Required[Annotated[T, ...]] +@lru_cache(maxsize=8096) +def strip_annotated_type(typ: type) -> type: + if is_required_type(typ) or is_annotated_type(typ): + return strip_annotated_type(cast(type, get_args(typ)[0])) + + return typ + + +def extract_type_arg(typ: type, index: int) -> type: + args = get_args(typ) + try: + return cast(type, args[index]) + except IndexError as err: + raise RuntimeError(f"Expected type {typ} to have a type argument at index {index} but it did not") from err + + +def extract_type_var_from_base( + typ: type, + *, + generic_bases: tuple[type, ...], + index: int, + failure_message: str | None = None, +) -> type: + """Given a type like `Foo[T]`, returns the generic type variable `T`. + + This also handles the case where a concrete subclass is given, e.g. + ```py + class MyResponse(Foo[bytes]): + ... + + extract_type_var(MyResponse, bases=(Foo,), index=0) -> bytes + ``` + + And where a generic subclass is given: + ```py + _T = TypeVar('_T') + class MyResponse(Foo[_T]): + ... + + extract_type_var(MyResponse[bytes], bases=(Foo,), index=0) -> bytes + ``` + """ + cls = cast(object, get_origin(typ) or typ) + if cls in generic_bases: # pyright: ignore[reportUnnecessaryContains] + # we're given the class directly + return extract_type_arg(typ, index) + + # if a subclass is given + # --- + # this is needed as __orig_bases__ is not present in the typeshed stubs + # because it is intended to be for internal use only, however there does + # not seem to be a way to resolve generic TypeVars for inherited subclasses + # without using it. + if isinstance(cls, InheritsGeneric): + target_base_class: Any | None = None + for base in cls.__orig_bases__: + if base.__origin__ in generic_bases: + target_base_class = base + break + + if target_base_class is None: + raise RuntimeError( + "Could not find the generic base class;\n" + "This should never happen;\n" + f"Does {cls} inherit from one of {generic_bases} ?" + ) + + extracted = extract_type_arg(target_base_class, index) + if is_typevar(extracted): + # If the extracted type argument is itself a type variable + # then that means the subclass itself is generic, so we have + # to resolve the type argument from the class itself, not + # the base class. + # + # Note: if there is more than 1 type argument, the subclass could + # change the ordering of the type arguments, this is not currently + # supported. + return extract_type_arg(typ, index) + + return extracted + + raise RuntimeError(failure_message or f"Could not resolve inner type variable at index {index} for {typ}") diff --git a/src/agentex_sdk/_utils/_utils.py b/src/agentex_sdk/_utils/_utils.py new file mode 100644 index 00000000..ea3cf3f2 --- /dev/null +++ b/src/agentex_sdk/_utils/_utils.py @@ -0,0 +1,422 @@ +from __future__ import annotations + +import os +import re +import inspect +import functools +from typing import ( + Any, + Tuple, + Mapping, + TypeVar, + Callable, + Iterable, + Sequence, + cast, + overload, +) +from pathlib import Path +from datetime import date, datetime +from typing_extensions import TypeGuard + +import sniffio + +from .._types import NotGiven, FileTypes, NotGivenOr, HeadersLike +from .._compat import parse_date as parse_date, parse_datetime as parse_datetime + +_T = TypeVar("_T") +_TupleT = TypeVar("_TupleT", bound=Tuple[object, ...]) +_MappingT = TypeVar("_MappingT", bound=Mapping[str, object]) +_SequenceT = TypeVar("_SequenceT", bound=Sequence[object]) +CallableT = TypeVar("CallableT", bound=Callable[..., Any]) + + +def flatten(t: Iterable[Iterable[_T]]) -> list[_T]: + return [item for sublist in t for item in sublist] + + +def extract_files( + # TODO: this needs to take Dict but variance issues..... + # create protocol type ? + query: Mapping[str, object], + *, + paths: Sequence[Sequence[str]], +) -> list[tuple[str, FileTypes]]: + """Recursively extract files from the given dictionary based on specified paths. + + A path may look like this ['foo', 'files', '', 'data']. + + Note: this mutates the given dictionary. + """ + files: list[tuple[str, FileTypes]] = [] + for path in paths: + files.extend(_extract_items(query, path, index=0, flattened_key=None)) + return files + + +def _extract_items( + obj: object, + path: Sequence[str], + *, + index: int, + flattened_key: str | None, +) -> list[tuple[str, FileTypes]]: + try: + key = path[index] + except IndexError: + if isinstance(obj, NotGiven): + # no value was provided - we can safely ignore + return [] + + # cyclical import + from .._files import assert_is_file_content + + # We have exhausted the path, return the entry we found. + assert flattened_key is not None + + if is_list(obj): + files: list[tuple[str, FileTypes]] = [] + for entry in obj: + assert_is_file_content(entry, key=flattened_key + "[]" if flattened_key else "") + files.append((flattened_key + "[]", cast(FileTypes, entry))) + return files + + assert_is_file_content(obj, key=flattened_key) + return [(flattened_key, cast(FileTypes, obj))] + + index += 1 + if is_dict(obj): + try: + # We are at the last entry in the path so we must remove the field + if (len(path)) == index: + item = obj.pop(key) + else: + item = obj[key] + except KeyError: + # Key was not present in the dictionary, this is not indicative of an error + # as the given path may not point to a required field. We also do not want + # to enforce required fields as the API may differ from the spec in some cases. + return [] + if flattened_key is None: + flattened_key = key + else: + flattened_key += f"[{key}]" + return _extract_items( + item, + path, + index=index, + flattened_key=flattened_key, + ) + elif is_list(obj): + if key != "": + return [] + + return flatten( + [ + _extract_items( + item, + path, + index=index, + flattened_key=flattened_key + "[]" if flattened_key is not None else "[]", + ) + for item in obj + ] + ) + + # Something unexpected was passed, just ignore it. + return [] + + +def is_given(obj: NotGivenOr[_T]) -> TypeGuard[_T]: + return not isinstance(obj, NotGiven) + + +# Type safe methods for narrowing types with TypeVars. +# The default narrowing for isinstance(obj, dict) is dict[unknown, unknown], +# however this cause Pyright to rightfully report errors. As we know we don't +# care about the contained types we can safely use `object` in it's place. +# +# There are two separate functions defined, `is_*` and `is_*_t` for different use cases. +# `is_*` is for when you're dealing with an unknown input +# `is_*_t` is for when you're narrowing a known union type to a specific subset + + +def is_tuple(obj: object) -> TypeGuard[tuple[object, ...]]: + return isinstance(obj, tuple) + + +def is_tuple_t(obj: _TupleT | object) -> TypeGuard[_TupleT]: + return isinstance(obj, tuple) + + +def is_sequence(obj: object) -> TypeGuard[Sequence[object]]: + return isinstance(obj, Sequence) + + +def is_sequence_t(obj: _SequenceT | object) -> TypeGuard[_SequenceT]: + return isinstance(obj, Sequence) + + +def is_mapping(obj: object) -> TypeGuard[Mapping[str, object]]: + return isinstance(obj, Mapping) + + +def is_mapping_t(obj: _MappingT | object) -> TypeGuard[_MappingT]: + return isinstance(obj, Mapping) + + +def is_dict(obj: object) -> TypeGuard[dict[object, object]]: + return isinstance(obj, dict) + + +def is_list(obj: object) -> TypeGuard[list[object]]: + return isinstance(obj, list) + + +def is_iterable(obj: object) -> TypeGuard[Iterable[object]]: + return isinstance(obj, Iterable) + + +def deepcopy_minimal(item: _T) -> _T: + """Minimal reimplementation of copy.deepcopy() that will only copy certain object types: + + - mappings, e.g. `dict` + - list + + This is done for performance reasons. + """ + if is_mapping(item): + return cast(_T, {k: deepcopy_minimal(v) for k, v in item.items()}) + if is_list(item): + return cast(_T, [deepcopy_minimal(entry) for entry in item]) + return item + + +# copied from https://github.com/Rapptz/RoboDanny +def human_join(seq: Sequence[str], *, delim: str = ", ", final: str = "or") -> str: + size = len(seq) + if size == 0: + return "" + + if size == 1: + return seq[0] + + if size == 2: + return f"{seq[0]} {final} {seq[1]}" + + return delim.join(seq[:-1]) + f" {final} {seq[-1]}" + + +def quote(string: str) -> str: + """Add single quotation marks around the given string. Does *not* do any escaping.""" + return f"'{string}'" + + +def required_args(*variants: Sequence[str]) -> Callable[[CallableT], CallableT]: + """Decorator to enforce a given set of arguments or variants of arguments are passed to the decorated function. + + Useful for enforcing runtime validation of overloaded functions. + + Example usage: + ```py + @overload + def foo(*, a: str) -> str: ... + + + @overload + def foo(*, b: bool) -> str: ... + + + # This enforces the same constraints that a static type checker would + # i.e. that either a or b must be passed to the function + @required_args(["a"], ["b"]) + def foo(*, a: str | None = None, b: bool | None = None) -> str: ... + ``` + """ + + def inner(func: CallableT) -> CallableT: + params = inspect.signature(func).parameters + positional = [ + name + for name, param in params.items() + if param.kind + in { + param.POSITIONAL_ONLY, + param.POSITIONAL_OR_KEYWORD, + } + ] + + @functools.wraps(func) + def wrapper(*args: object, **kwargs: object) -> object: + given_params: set[str] = set() + for i, _ in enumerate(args): + try: + given_params.add(positional[i]) + except IndexError: + raise TypeError( + f"{func.__name__}() takes {len(positional)} argument(s) but {len(args)} were given" + ) from None + + for key in kwargs.keys(): + given_params.add(key) + + for variant in variants: + matches = all((param in given_params for param in variant)) + if matches: + break + else: # no break + if len(variants) > 1: + variations = human_join( + ["(" + human_join([quote(arg) for arg in variant], final="and") + ")" for variant in variants] + ) + msg = f"Missing required arguments; Expected either {variations} arguments to be given" + else: + assert len(variants) > 0 + + # TODO: this error message is not deterministic + missing = list(set(variants[0]) - given_params) + if len(missing) > 1: + msg = f"Missing required arguments: {human_join([quote(arg) for arg in missing])}" + else: + msg = f"Missing required argument: {quote(missing[0])}" + raise TypeError(msg) + return func(*args, **kwargs) + + return wrapper # type: ignore + + return inner + + +_K = TypeVar("_K") +_V = TypeVar("_V") + + +@overload +def strip_not_given(obj: None) -> None: ... + + +@overload +def strip_not_given(obj: Mapping[_K, _V | NotGiven]) -> dict[_K, _V]: ... + + +@overload +def strip_not_given(obj: object) -> object: ... + + +def strip_not_given(obj: object | None) -> object: + """Remove all top-level keys where their values are instances of `NotGiven`""" + if obj is None: + return None + + if not is_mapping(obj): + return obj + + return {key: value for key, value in obj.items() if not isinstance(value, NotGiven)} + + +def coerce_integer(val: str) -> int: + return int(val, base=10) + + +def coerce_float(val: str) -> float: + return float(val) + + +def coerce_boolean(val: str) -> bool: + return val == "true" or val == "1" or val == "on" + + +def maybe_coerce_integer(val: str | None) -> int | None: + if val is None: + return None + return coerce_integer(val) + + +def maybe_coerce_float(val: str | None) -> float | None: + if val is None: + return None + return coerce_float(val) + + +def maybe_coerce_boolean(val: str | None) -> bool | None: + if val is None: + return None + return coerce_boolean(val) + + +def removeprefix(string: str, prefix: str) -> str: + """Remove a prefix from a string. + + Backport of `str.removeprefix` for Python < 3.9 + """ + if string.startswith(prefix): + return string[len(prefix) :] + return string + + +def removesuffix(string: str, suffix: str) -> str: + """Remove a suffix from a string. + + Backport of `str.removesuffix` for Python < 3.9 + """ + if string.endswith(suffix): + return string[: -len(suffix)] + return string + + +def file_from_path(path: str) -> FileTypes: + contents = Path(path).read_bytes() + file_name = os.path.basename(path) + return (file_name, contents) + + +def get_required_header(headers: HeadersLike, header: str) -> str: + lower_header = header.lower() + if is_mapping_t(headers): + # mypy doesn't understand the type narrowing here + for k, v in headers.items(): # type: ignore + if k.lower() == lower_header and isinstance(v, str): + return v + + # to deal with the case where the header looks like Stainless-Event-Id + intercaps_header = re.sub(r"([^\w])(\w)", lambda pat: pat.group(1) + pat.group(2).upper(), header.capitalize()) + + for normalized_header in [header, lower_header, header.upper(), intercaps_header]: + value = headers.get(normalized_header) + if value: + return value + + raise ValueError(f"Could not find {header} header") + + +def get_async_library() -> str: + try: + return sniffio.current_async_library() + except Exception: + return "false" + + +def lru_cache(*, maxsize: int | None = 128) -> Callable[[CallableT], CallableT]: + """A version of functools.lru_cache that retains the type signature + for the wrapped function arguments. + """ + wrapper = functools.lru_cache( # noqa: TID251 + maxsize=maxsize, + ) + return cast(Any, wrapper) # type: ignore[no-any-return] + + +def json_safe(data: object) -> object: + """Translates a mapping / sequence recursively in the same fashion + as `pydantic` v2's `model_dump(mode="json")`. + """ + if is_mapping(data): + return {json_safe(key): json_safe(value) for key, value in data.items()} + + if is_iterable(data) and not isinstance(data, (str, bytes, bytearray)): + return [json_safe(item) for item in data] + + if isinstance(data, (datetime, date)): + return data.isoformat() + + return data diff --git a/src/agentex_sdk/_version.py b/src/agentex_sdk/_version.py new file mode 100644 index 00000000..c88b548c --- /dev/null +++ b/src/agentex_sdk/_version.py @@ -0,0 +1,4 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +__title__ = "agentex_sdk" +__version__ = "0.0.1-alpha.0" diff --git a/src/agentex_sdk/lib/.keep b/src/agentex_sdk/lib/.keep new file mode 100644 index 00000000..5e2c99fd --- /dev/null +++ b/src/agentex_sdk/lib/.keep @@ -0,0 +1,4 @@ +File generated from our OpenAPI spec by Stainless. + +This directory can be used to store custom files to expand the SDK. +It is ignored by Stainless code generation and its content (other than this keep file) won't be touched. \ No newline at end of file diff --git a/src/agentex_sdk/py.typed b/src/agentex_sdk/py.typed new file mode 100644 index 00000000..e69de29b diff --git a/src/agentex_sdk/resources/__init__.py b/src/agentex_sdk/resources/__init__.py new file mode 100644 index 00000000..d4758f92 --- /dev/null +++ b/src/agentex_sdk/resources/__init__.py @@ -0,0 +1,117 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .echo import ( + EchoResource, + AsyncEchoResource, + EchoResourceWithRawResponse, + AsyncEchoResourceWithRawResponse, + EchoResourceWithStreamingResponse, + AsyncEchoResourceWithStreamingResponse, +) +from .spans import ( + SpansResource, + AsyncSpansResource, + SpansResourceWithRawResponse, + AsyncSpansResourceWithRawResponse, + SpansResourceWithStreamingResponse, + AsyncSpansResourceWithStreamingResponse, +) +from .tasks import ( + TasksResource, + AsyncTasksResource, + TasksResourceWithRawResponse, + AsyncTasksResourceWithRawResponse, + TasksResourceWithStreamingResponse, + AsyncTasksResourceWithStreamingResponse, +) +from .agents import ( + AgentsResource, + AsyncAgentsResource, + AgentsResourceWithRawResponse, + AsyncAgentsResourceWithRawResponse, + AgentsResourceWithStreamingResponse, + AsyncAgentsResourceWithStreamingResponse, +) +from .events import ( + EventsResource, + AsyncEventsResource, + EventsResourceWithRawResponse, + AsyncEventsResourceWithRawResponse, + EventsResourceWithStreamingResponse, + AsyncEventsResourceWithStreamingResponse, +) +from .states import ( + StatesResource, + AsyncStatesResource, + StatesResourceWithRawResponse, + AsyncStatesResourceWithRawResponse, + StatesResourceWithStreamingResponse, + AsyncStatesResourceWithStreamingResponse, +) +from .tracker import ( + TrackerResource, + AsyncTrackerResource, + TrackerResourceWithRawResponse, + AsyncTrackerResourceWithRawResponse, + TrackerResourceWithStreamingResponse, + AsyncTrackerResourceWithStreamingResponse, +) +from .messages import ( + MessagesResource, + AsyncMessagesResource, + MessagesResourceWithRawResponse, + AsyncMessagesResourceWithRawResponse, + MessagesResourceWithStreamingResponse, + AsyncMessagesResourceWithStreamingResponse, +) + +__all__ = [ + "EchoResource", + "AsyncEchoResource", + "EchoResourceWithRawResponse", + "AsyncEchoResourceWithRawResponse", + "EchoResourceWithStreamingResponse", + "AsyncEchoResourceWithStreamingResponse", + "AgentsResource", + "AsyncAgentsResource", + "AgentsResourceWithRawResponse", + "AsyncAgentsResourceWithRawResponse", + "AgentsResourceWithStreamingResponse", + "AsyncAgentsResourceWithStreamingResponse", + "TasksResource", + "AsyncTasksResource", + "TasksResourceWithRawResponse", + "AsyncTasksResourceWithRawResponse", + "TasksResourceWithStreamingResponse", + "AsyncTasksResourceWithStreamingResponse", + "MessagesResource", + "AsyncMessagesResource", + "MessagesResourceWithRawResponse", + "AsyncMessagesResourceWithRawResponse", + "MessagesResourceWithStreamingResponse", + "AsyncMessagesResourceWithStreamingResponse", + "SpansResource", + "AsyncSpansResource", + "SpansResourceWithRawResponse", + "AsyncSpansResourceWithRawResponse", + "SpansResourceWithStreamingResponse", + "AsyncSpansResourceWithStreamingResponse", + "StatesResource", + "AsyncStatesResource", + "StatesResourceWithRawResponse", + "AsyncStatesResourceWithRawResponse", + "StatesResourceWithStreamingResponse", + "AsyncStatesResourceWithStreamingResponse", + "EventsResource", + "AsyncEventsResource", + "EventsResourceWithRawResponse", + "AsyncEventsResourceWithRawResponse", + "EventsResourceWithStreamingResponse", + "AsyncEventsResourceWithStreamingResponse", + "TrackerResource", + "AsyncTrackerResource", + "TrackerResourceWithRawResponse", + "AsyncTrackerResourceWithRawResponse", + "TrackerResourceWithStreamingResponse", + "AsyncTrackerResourceWithStreamingResponse", +] diff --git a/src/agentex_sdk/resources/agents/__init__.py b/src/agentex_sdk/resources/agents/__init__.py new file mode 100644 index 00000000..374345e0 --- /dev/null +++ b/src/agentex_sdk/resources/agents/__init__.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .name import ( + NameResource, + AsyncNameResource, + NameResourceWithRawResponse, + AsyncNameResourceWithRawResponse, + NameResourceWithStreamingResponse, + AsyncNameResourceWithStreamingResponse, +) +from .agents import ( + AgentsResource, + AsyncAgentsResource, + AgentsResourceWithRawResponse, + AsyncAgentsResourceWithRawResponse, + AgentsResourceWithStreamingResponse, + AsyncAgentsResourceWithStreamingResponse, +) + +__all__ = [ + "NameResource", + "AsyncNameResource", + "NameResourceWithRawResponse", + "AsyncNameResourceWithRawResponse", + "NameResourceWithStreamingResponse", + "AsyncNameResourceWithStreamingResponse", + "AgentsResource", + "AsyncAgentsResource", + "AgentsResourceWithRawResponse", + "AsyncAgentsResourceWithRawResponse", + "AgentsResourceWithStreamingResponse", + "AsyncAgentsResourceWithStreamingResponse", +] diff --git a/src/agentex_sdk/resources/agents/agents.py b/src/agentex_sdk/resources/agents/agents.py new file mode 100644 index 00000000..7b914d65 --- /dev/null +++ b/src/agentex_sdk/resources/agents/agents.py @@ -0,0 +1,487 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional + +import httpx + +from .name import ( + NameResource, + AsyncNameResource, + NameResourceWithRawResponse, + AsyncNameResourceWithRawResponse, + NameResourceWithStreamingResponse, + AsyncNameResourceWithStreamingResponse, +) +from ...types import AcpType, agent_list_params, agent_register_params +from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._utils import maybe_transform, async_maybe_transform +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ...types.agent import Agent +from ..._base_client import make_request_options +from ...types.acp_type import AcpType +from ...types.agent_list_response import AgentListResponse + +__all__ = ["AgentsResource", "AsyncAgentsResource"] + + +class AgentsResource(SyncAPIResource): + @cached_property + def name(self) -> NameResource: + return NameResource(self._client) + + @cached_property + def with_raw_response(self) -> AgentsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return AgentsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AgentsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return AgentsResourceWithStreamingResponse(self) + + def retrieve( + self, + agent_id: str, + *, + # 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, + ) -> Agent: + """ + Get an agent by its unique ID. + + Args: + 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 + """ + if not agent_id: + raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") + return self._get( + f"/agents/{agent_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + def list( + self, + *, + task_id: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> AgentListResponse: + """ + List all registered agents, optionally filtered by query parameters. + + Args: + task_id: Task ID + + 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 + """ + return self._get( + "/agents", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform({"task_id": task_id}, agent_list_params.AgentListParams), + ), + cast_to=AgentListResponse, + ) + + def delete( + self, + agent_id: str, + *, + # 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, + ) -> Agent: + """ + Delete an agent by its unique ID. + + Args: + 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 + """ + if not agent_id: + raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") + return self._delete( + f"/agents/{agent_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + def register( + self, + *, + acp_type: AcpType, + acp_url: str, + description: str, + name: str, + agent_id: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> Agent: + """ + Register a new agent or update an existing one. + + Args: + acp_type: The type of ACP to use for the agent. + + acp_url: The URL of the ACP server for the agent. + + description: The description of the agent. + + name: The unique name of the agent. + + agent_id: Optional agent ID if the agent already exists and needs to be updated. + + 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 + """ + return self._post( + "/agents/register", + body=maybe_transform( + { + "acp_type": acp_type, + "acp_url": acp_url, + "description": description, + "name": name, + "agent_id": agent_id, + }, + agent_register_params.AgentRegisterParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + +class AsyncAgentsResource(AsyncAPIResource): + @cached_property + def name(self) -> AsyncNameResource: + return AsyncNameResource(self._client) + + @cached_property + def with_raw_response(self) -> AsyncAgentsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncAgentsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncAgentsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return AsyncAgentsResourceWithStreamingResponse(self) + + async def retrieve( + self, + agent_id: str, + *, + # 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, + ) -> Agent: + """ + Get an agent by its unique ID. + + Args: + 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 + """ + if not agent_id: + raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") + return await self._get( + f"/agents/{agent_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + async def list( + self, + *, + task_id: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> AgentListResponse: + """ + List all registered agents, optionally filtered by query parameters. + + Args: + task_id: Task ID + + 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 + """ + return await self._get( + "/agents", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform({"task_id": task_id}, agent_list_params.AgentListParams), + ), + cast_to=AgentListResponse, + ) + + async def delete( + self, + agent_id: str, + *, + # 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, + ) -> Agent: + """ + Delete an agent by its unique ID. + + Args: + 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 + """ + if not agent_id: + raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") + return await self._delete( + f"/agents/{agent_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + async def register( + self, + *, + acp_type: AcpType, + acp_url: str, + description: str, + name: str, + agent_id: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> Agent: + """ + Register a new agent or update an existing one. + + Args: + acp_type: The type of ACP to use for the agent. + + acp_url: The URL of the ACP server for the agent. + + description: The description of the agent. + + name: The unique name of the agent. + + agent_id: Optional agent ID if the agent already exists and needs to be updated. + + 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 + """ + return await self._post( + "/agents/register", + body=await async_maybe_transform( + { + "acp_type": acp_type, + "acp_url": acp_url, + "description": description, + "name": name, + "agent_id": agent_id, + }, + agent_register_params.AgentRegisterParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + +class AgentsResourceWithRawResponse: + def __init__(self, agents: AgentsResource) -> None: + self._agents = agents + + self.retrieve = to_raw_response_wrapper( + agents.retrieve, + ) + self.list = to_raw_response_wrapper( + agents.list, + ) + self.delete = to_raw_response_wrapper( + agents.delete, + ) + self.register = to_raw_response_wrapper( + agents.register, + ) + + @cached_property + def name(self) -> NameResourceWithRawResponse: + return NameResourceWithRawResponse(self._agents.name) + + +class AsyncAgentsResourceWithRawResponse: + def __init__(self, agents: AsyncAgentsResource) -> None: + self._agents = agents + + self.retrieve = async_to_raw_response_wrapper( + agents.retrieve, + ) + self.list = async_to_raw_response_wrapper( + agents.list, + ) + self.delete = async_to_raw_response_wrapper( + agents.delete, + ) + self.register = async_to_raw_response_wrapper( + agents.register, + ) + + @cached_property + def name(self) -> AsyncNameResourceWithRawResponse: + return AsyncNameResourceWithRawResponse(self._agents.name) + + +class AgentsResourceWithStreamingResponse: + def __init__(self, agents: AgentsResource) -> None: + self._agents = agents + + self.retrieve = to_streamed_response_wrapper( + agents.retrieve, + ) + self.list = to_streamed_response_wrapper( + agents.list, + ) + self.delete = to_streamed_response_wrapper( + agents.delete, + ) + self.register = to_streamed_response_wrapper( + agents.register, + ) + + @cached_property + def name(self) -> NameResourceWithStreamingResponse: + return NameResourceWithStreamingResponse(self._agents.name) + + +class AsyncAgentsResourceWithStreamingResponse: + def __init__(self, agents: AsyncAgentsResource) -> None: + self._agents = agents + + self.retrieve = async_to_streamed_response_wrapper( + agents.retrieve, + ) + self.list = async_to_streamed_response_wrapper( + agents.list, + ) + self.delete = async_to_streamed_response_wrapper( + agents.delete, + ) + self.register = async_to_streamed_response_wrapper( + agents.register, + ) + + @cached_property + def name(self) -> AsyncNameResourceWithStreamingResponse: + return AsyncNameResourceWithStreamingResponse(self._agents.name) diff --git a/src/agentex_sdk/resources/agents/name.py b/src/agentex_sdk/resources/agents/name.py new file mode 100644 index 00000000..167983b1 --- /dev/null +++ b/src/agentex_sdk/resources/agents/name.py @@ -0,0 +1,241 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import httpx + +from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ...types.agent import Agent +from ..._base_client import make_request_options + +__all__ = ["NameResource", "AsyncNameResource"] + + +class NameResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> NameResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return NameResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> NameResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return NameResourceWithStreamingResponse(self) + + def retrieve( + self, + agent_name: str, + *, + # 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, + ) -> Agent: + """ + Get an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return self._get( + f"/agents/name/{agent_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + def delete( + self, + agent_name: str, + *, + # 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, + ) -> Agent: + """ + Delete an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return self._delete( + f"/agents/name/{agent_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + +class AsyncNameResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncNameResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncNameResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncNameResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return AsyncNameResourceWithStreamingResponse(self) + + async def retrieve( + self, + agent_name: str, + *, + # 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, + ) -> Agent: + """ + Get an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return await self._get( + f"/agents/name/{agent_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + async def delete( + self, + agent_name: str, + *, + # 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, + ) -> Agent: + """ + Delete an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return await self._delete( + f"/agents/name/{agent_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + +class NameResourceWithRawResponse: + def __init__(self, name: NameResource) -> None: + self._name = name + + self.retrieve = to_raw_response_wrapper( + name.retrieve, + ) + self.delete = to_raw_response_wrapper( + name.delete, + ) + + +class AsyncNameResourceWithRawResponse: + def __init__(self, name: AsyncNameResource) -> None: + self._name = name + + self.retrieve = async_to_raw_response_wrapper( + name.retrieve, + ) + self.delete = async_to_raw_response_wrapper( + name.delete, + ) + + +class NameResourceWithStreamingResponse: + def __init__(self, name: NameResource) -> None: + self._name = name + + self.retrieve = to_streamed_response_wrapper( + name.retrieve, + ) + self.delete = to_streamed_response_wrapper( + name.delete, + ) + + +class AsyncNameResourceWithStreamingResponse: + def __init__(self, name: AsyncNameResource) -> None: + self._name = name + + self.retrieve = async_to_streamed_response_wrapper( + name.retrieve, + ) + self.delete = async_to_streamed_response_wrapper( + name.delete, + ) diff --git a/src/agentex_sdk/resources/echo.py b/src/agentex_sdk/resources/echo.py new file mode 100644 index 00000000..d80adb34 --- /dev/null +++ b/src/agentex_sdk/resources/echo.py @@ -0,0 +1,162 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import httpx + +from ..types import echo_send_params +from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._utils import maybe_transform, async_maybe_transform +from .._compat import cached_property +from .._resource import SyncAPIResource, AsyncAPIResource +from .._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from .._base_client import make_request_options + +__all__ = ["EchoResource", "AsyncEchoResource"] + + +class EchoResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> EchoResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return EchoResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> EchoResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return EchoResourceWithStreamingResponse(self) + + def send( + self, + *, + message: str, + # 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, + ) -> object: + """ + Echo + + Args: + 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 + """ + return self._post( + "/echo", + body=maybe_transform({"message": message}, echo_send_params.EchoSendParams), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + ) + + +class AsyncEchoResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncEchoResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncEchoResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncEchoResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return AsyncEchoResourceWithStreamingResponse(self) + + async def send( + self, + *, + message: str, + # 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, + ) -> object: + """ + Echo + + Args: + 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 + """ + return await self._post( + "/echo", + body=await async_maybe_transform({"message": message}, echo_send_params.EchoSendParams), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + ) + + +class EchoResourceWithRawResponse: + def __init__(self, echo: EchoResource) -> None: + self._echo = echo + + self.send = to_raw_response_wrapper( + echo.send, + ) + + +class AsyncEchoResourceWithRawResponse: + def __init__(self, echo: AsyncEchoResource) -> None: + self._echo = echo + + self.send = async_to_raw_response_wrapper( + echo.send, + ) + + +class EchoResourceWithStreamingResponse: + def __init__(self, echo: EchoResource) -> None: + self._echo = echo + + self.send = to_streamed_response_wrapper( + echo.send, + ) + + +class AsyncEchoResourceWithStreamingResponse: + def __init__(self, echo: AsyncEchoResource) -> None: + self._echo = echo + + self.send = async_to_streamed_response_wrapper( + echo.send, + ) diff --git a/src/agentex_sdk/resources/events.py b/src/agentex_sdk/resources/events.py new file mode 100644 index 00000000..652de518 --- /dev/null +++ b/src/agentex_sdk/resources/events.py @@ -0,0 +1,294 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional + +import httpx + +from ..types import event_list_params +from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._utils import maybe_transform, async_maybe_transform +from .._compat import cached_property +from .._resource import SyncAPIResource, AsyncAPIResource +from .._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ..types.event import Event +from .._base_client import make_request_options +from ..types.event_list_response import EventListResponse + +__all__ = ["EventsResource", "AsyncEventsResource"] + + +class EventsResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> EventsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return EventsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> EventsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return EventsResourceWithStreamingResponse(self) + + def retrieve( + self, + event_id: str, + *, + # 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, + ) -> Event: + """ + Get Event + + Args: + 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 + """ + if not event_id: + raise ValueError(f"Expected a non-empty value for `event_id` but received {event_id!r}") + return self._get( + f"/events/{event_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Event, + ) + + def list( + self, + *, + agent_id: str, + task_id: str, + last_processed_event_id: Optional[str] | NotGiven = NOT_GIVEN, + limit: Optional[int] | NotGiven = NOT_GIVEN, + # 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, + ) -> EventListResponse: + """ + List events for a specific task and agent. + + Optionally filter for events after a specific sequence ID. Results are ordered + by sequence_id. + + Args: + agent_id: The agent ID to filter events by + + task_id: The task ID to filter events by + + last_processed_event_id: Optional event ID to get events after this ID + + limit: Optional limit on number of results + + 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 + """ + return self._get( + "/events", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "agent_id": agent_id, + "task_id": task_id, + "last_processed_event_id": last_processed_event_id, + "limit": limit, + }, + event_list_params.EventListParams, + ), + ), + cast_to=EventListResponse, + ) + + +class AsyncEventsResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncEventsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncEventsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncEventsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return AsyncEventsResourceWithStreamingResponse(self) + + async def retrieve( + self, + event_id: str, + *, + # 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, + ) -> Event: + """ + Get Event + + Args: + 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 + """ + if not event_id: + raise ValueError(f"Expected a non-empty value for `event_id` but received {event_id!r}") + return await self._get( + f"/events/{event_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Event, + ) + + async def list( + self, + *, + agent_id: str, + task_id: str, + last_processed_event_id: Optional[str] | NotGiven = NOT_GIVEN, + limit: Optional[int] | NotGiven = NOT_GIVEN, + # 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, + ) -> EventListResponse: + """ + List events for a specific task and agent. + + Optionally filter for events after a specific sequence ID. Results are ordered + by sequence_id. + + Args: + agent_id: The agent ID to filter events by + + task_id: The task ID to filter events by + + last_processed_event_id: Optional event ID to get events after this ID + + limit: Optional limit on number of results + + 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 + """ + return await self._get( + "/events", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "agent_id": agent_id, + "task_id": task_id, + "last_processed_event_id": last_processed_event_id, + "limit": limit, + }, + event_list_params.EventListParams, + ), + ), + cast_to=EventListResponse, + ) + + +class EventsResourceWithRawResponse: + def __init__(self, events: EventsResource) -> None: + self._events = events + + self.retrieve = to_raw_response_wrapper( + events.retrieve, + ) + self.list = to_raw_response_wrapper( + events.list, + ) + + +class AsyncEventsResourceWithRawResponse: + def __init__(self, events: AsyncEventsResource) -> None: + self._events = events + + self.retrieve = async_to_raw_response_wrapper( + events.retrieve, + ) + self.list = async_to_raw_response_wrapper( + events.list, + ) + + +class EventsResourceWithStreamingResponse: + def __init__(self, events: EventsResource) -> None: + self._events = events + + self.retrieve = to_streamed_response_wrapper( + events.retrieve, + ) + self.list = to_streamed_response_wrapper( + events.list, + ) + + +class AsyncEventsResourceWithStreamingResponse: + def __init__(self, events: AsyncEventsResource) -> None: + self._events = events + + self.retrieve = async_to_streamed_response_wrapper( + events.retrieve, + ) + self.list = async_to_streamed_response_wrapper( + events.list, + ) diff --git a/src/agentex_sdk/resources/messages/__init__.py b/src/agentex_sdk/resources/messages/__init__.py new file mode 100644 index 00000000..389b8cc1 --- /dev/null +++ b/src/agentex_sdk/resources/messages/__init__.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .batch import ( + BatchResource, + AsyncBatchResource, + BatchResourceWithRawResponse, + AsyncBatchResourceWithRawResponse, + BatchResourceWithStreamingResponse, + AsyncBatchResourceWithStreamingResponse, +) +from .messages import ( + MessagesResource, + AsyncMessagesResource, + MessagesResourceWithRawResponse, + AsyncMessagesResourceWithRawResponse, + MessagesResourceWithStreamingResponse, + AsyncMessagesResourceWithStreamingResponse, +) + +__all__ = [ + "BatchResource", + "AsyncBatchResource", + "BatchResourceWithRawResponse", + "AsyncBatchResourceWithRawResponse", + "BatchResourceWithStreamingResponse", + "AsyncBatchResourceWithStreamingResponse", + "MessagesResource", + "AsyncMessagesResource", + "MessagesResourceWithRawResponse", + "AsyncMessagesResourceWithRawResponse", + "MessagesResourceWithStreamingResponse", + "AsyncMessagesResourceWithStreamingResponse", +] diff --git a/src/agentex_sdk/resources/messages/batch.py b/src/agentex_sdk/resources/messages/batch.py new file mode 100644 index 00000000..455683ea --- /dev/null +++ b/src/agentex_sdk/resources/messages/batch.py @@ -0,0 +1,270 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict, Iterable + +import httpx + +from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._utils import maybe_transform, async_maybe_transform +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ..._base_client import make_request_options +from ...types.messages import batch_create_params, batch_update_params +from ...types.messages.batch_create_response import BatchCreateResponse +from ...types.messages.batch_update_response import BatchUpdateResponse + +__all__ = ["BatchResource", "AsyncBatchResource"] + + +class BatchResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> BatchResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return BatchResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> BatchResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return BatchResourceWithStreamingResponse(self) + + def create( + self, + *, + contents: Iterable[batch_create_params.Content], + task_id: str, + # 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, + ) -> BatchCreateResponse: + """ + Batch Create Messages + + Args: + 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 + """ + return self._post( + "/messages/batch", + body=maybe_transform( + { + "contents": contents, + "task_id": task_id, + }, + batch_create_params.BatchCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=BatchCreateResponse, + ) + + def update( + self, + *, + task_id: str, + updates: Dict[str, batch_update_params.Updates], + # 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, + ) -> BatchUpdateResponse: + """ + Batch Update Messages + + Args: + 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 + """ + return self._put( + "/messages/batch", + body=maybe_transform( + { + "task_id": task_id, + "updates": updates, + }, + batch_update_params.BatchUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=BatchUpdateResponse, + ) + + +class AsyncBatchResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncBatchResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncBatchResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncBatchResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return AsyncBatchResourceWithStreamingResponse(self) + + async def create( + self, + *, + contents: Iterable[batch_create_params.Content], + task_id: str, + # 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, + ) -> BatchCreateResponse: + """ + Batch Create Messages + + Args: + 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 + """ + return await self._post( + "/messages/batch", + body=await async_maybe_transform( + { + "contents": contents, + "task_id": task_id, + }, + batch_create_params.BatchCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=BatchCreateResponse, + ) + + async def update( + self, + *, + task_id: str, + updates: Dict[str, batch_update_params.Updates], + # 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, + ) -> BatchUpdateResponse: + """ + Batch Update Messages + + Args: + 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 + """ + return await self._put( + "/messages/batch", + body=await async_maybe_transform( + { + "task_id": task_id, + "updates": updates, + }, + batch_update_params.BatchUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=BatchUpdateResponse, + ) + + +class BatchResourceWithRawResponse: + def __init__(self, batch: BatchResource) -> None: + self._batch = batch + + self.create = to_raw_response_wrapper( + batch.create, + ) + self.update = to_raw_response_wrapper( + batch.update, + ) + + +class AsyncBatchResourceWithRawResponse: + def __init__(self, batch: AsyncBatchResource) -> None: + self._batch = batch + + self.create = async_to_raw_response_wrapper( + batch.create, + ) + self.update = async_to_raw_response_wrapper( + batch.update, + ) + + +class BatchResourceWithStreamingResponse: + def __init__(self, batch: BatchResource) -> None: + self._batch = batch + + self.create = to_streamed_response_wrapper( + batch.create, + ) + self.update = to_streamed_response_wrapper( + batch.update, + ) + + +class AsyncBatchResourceWithStreamingResponse: + def __init__(self, batch: AsyncBatchResource) -> None: + self._batch = batch + + self.create = async_to_streamed_response_wrapper( + batch.create, + ) + self.update = async_to_streamed_response_wrapper( + batch.update, + ) diff --git a/src/agentex_sdk/resources/messages/messages.py b/src/agentex_sdk/resources/messages/messages.py new file mode 100644 index 00000000..fd15714b --- /dev/null +++ b/src/agentex_sdk/resources/messages/messages.py @@ -0,0 +1,491 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional + +import httpx + +from .batch import ( + BatchResource, + AsyncBatchResource, + BatchResourceWithRawResponse, + AsyncBatchResourceWithRawResponse, + BatchResourceWithStreamingResponse, + AsyncBatchResourceWithStreamingResponse, +) +from ...types import StreamingStatus, message_list_params, message_create_params, message_update_params +from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._utils import maybe_transform, async_maybe_transform +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ..._base_client import make_request_options +from ...types.task_message import TaskMessage +from ...types.streaming_status import StreamingStatus +from ...types.message_list_response import MessageListResponse + +__all__ = ["MessagesResource", "AsyncMessagesResource"] + + +class MessagesResource(SyncAPIResource): + @cached_property + def batch(self) -> BatchResource: + return BatchResource(self._client) + + @cached_property + def with_raw_response(self) -> MessagesResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return MessagesResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> MessagesResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return MessagesResourceWithStreamingResponse(self) + + def create( + self, + *, + content: message_create_params.Content, + task_id: str, + streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + # 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, + ) -> TaskMessage: + """ + Create Message + + Args: + 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 + """ + return self._post( + "/messages", + body=maybe_transform( + { + "content": content, + "task_id": task_id, + "streaming_status": streaming_status, + }, + message_create_params.MessageCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=TaskMessage, + ) + + def retrieve( + self, + message_id: str, + *, + # 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, + ) -> TaskMessage: + """ + Get Message + + Args: + 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 + """ + if not message_id: + raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}") + return self._get( + f"/messages/{message_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=TaskMessage, + ) + + def update( + self, + message_id: str, + *, + content: message_update_params.Content, + task_id: str, + streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + # 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, + ) -> TaskMessage: + """ + Update Message + + Args: + 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 + """ + if not message_id: + raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}") + return self._put( + f"/messages/{message_id}", + body=maybe_transform( + { + "content": content, + "task_id": task_id, + "streaming_status": streaming_status, + }, + message_update_params.MessageUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=TaskMessage, + ) + + def list( + self, + *, + task_id: str, + limit: Optional[int] | NotGiven = NOT_GIVEN, + # 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, + ) -> MessageListResponse: + """ + List Messages + + Args: + 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 + """ + return self._get( + "/messages", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "task_id": task_id, + "limit": limit, + }, + message_list_params.MessageListParams, + ), + ), + cast_to=MessageListResponse, + ) + + +class AsyncMessagesResource(AsyncAPIResource): + @cached_property + def batch(self) -> AsyncBatchResource: + return AsyncBatchResource(self._client) + + @cached_property + def with_raw_response(self) -> AsyncMessagesResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncMessagesResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncMessagesResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return AsyncMessagesResourceWithStreamingResponse(self) + + async def create( + self, + *, + content: message_create_params.Content, + task_id: str, + streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + # 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, + ) -> TaskMessage: + """ + Create Message + + Args: + 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 + """ + return await self._post( + "/messages", + body=await async_maybe_transform( + { + "content": content, + "task_id": task_id, + "streaming_status": streaming_status, + }, + message_create_params.MessageCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=TaskMessage, + ) + + async def retrieve( + self, + message_id: str, + *, + # 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, + ) -> TaskMessage: + """ + Get Message + + Args: + 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 + """ + if not message_id: + raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}") + return await self._get( + f"/messages/{message_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=TaskMessage, + ) + + async def update( + self, + message_id: str, + *, + content: message_update_params.Content, + task_id: str, + streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + # 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, + ) -> TaskMessage: + """ + Update Message + + Args: + 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 + """ + if not message_id: + raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}") + return await self._put( + f"/messages/{message_id}", + body=await async_maybe_transform( + { + "content": content, + "task_id": task_id, + "streaming_status": streaming_status, + }, + message_update_params.MessageUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=TaskMessage, + ) + + async def list( + self, + *, + task_id: str, + limit: Optional[int] | NotGiven = NOT_GIVEN, + # 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, + ) -> MessageListResponse: + """ + List Messages + + Args: + 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 + """ + return await self._get( + "/messages", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "task_id": task_id, + "limit": limit, + }, + message_list_params.MessageListParams, + ), + ), + cast_to=MessageListResponse, + ) + + +class MessagesResourceWithRawResponse: + def __init__(self, messages: MessagesResource) -> None: + self._messages = messages + + self.create = to_raw_response_wrapper( + messages.create, + ) + self.retrieve = to_raw_response_wrapper( + messages.retrieve, + ) + self.update = to_raw_response_wrapper( + messages.update, + ) + self.list = to_raw_response_wrapper( + messages.list, + ) + + @cached_property + def batch(self) -> BatchResourceWithRawResponse: + return BatchResourceWithRawResponse(self._messages.batch) + + +class AsyncMessagesResourceWithRawResponse: + def __init__(self, messages: AsyncMessagesResource) -> None: + self._messages = messages + + self.create = async_to_raw_response_wrapper( + messages.create, + ) + self.retrieve = async_to_raw_response_wrapper( + messages.retrieve, + ) + self.update = async_to_raw_response_wrapper( + messages.update, + ) + self.list = async_to_raw_response_wrapper( + messages.list, + ) + + @cached_property + def batch(self) -> AsyncBatchResourceWithRawResponse: + return AsyncBatchResourceWithRawResponse(self._messages.batch) + + +class MessagesResourceWithStreamingResponse: + def __init__(self, messages: MessagesResource) -> None: + self._messages = messages + + self.create = to_streamed_response_wrapper( + messages.create, + ) + self.retrieve = to_streamed_response_wrapper( + messages.retrieve, + ) + self.update = to_streamed_response_wrapper( + messages.update, + ) + self.list = to_streamed_response_wrapper( + messages.list, + ) + + @cached_property + def batch(self) -> BatchResourceWithStreamingResponse: + return BatchResourceWithStreamingResponse(self._messages.batch) + + +class AsyncMessagesResourceWithStreamingResponse: + def __init__(self, messages: AsyncMessagesResource) -> None: + self._messages = messages + + self.create = async_to_streamed_response_wrapper( + messages.create, + ) + self.retrieve = async_to_streamed_response_wrapper( + messages.retrieve, + ) + self.update = async_to_streamed_response_wrapper( + messages.update, + ) + self.list = async_to_streamed_response_wrapper( + messages.list, + ) + + @cached_property + def batch(self) -> AsyncBatchResourceWithStreamingResponse: + return AsyncBatchResourceWithStreamingResponse(self._messages.batch) diff --git a/src/agentex_sdk/resources/spans.py b/src/agentex_sdk/resources/spans.py new file mode 100644 index 00000000..541c951c --- /dev/null +++ b/src/agentex_sdk/resources/spans.py @@ -0,0 +1,557 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict, Union, Iterable, Optional +from datetime import datetime + +import httpx + +from ..types import span_list_params, span_create_params, span_update_params +from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._utils import maybe_transform, async_maybe_transform +from .._compat import cached_property +from .._resource import SyncAPIResource, AsyncAPIResource +from .._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ..types.span import Span +from .._base_client import make_request_options +from ..types.span_list_response import SpanListResponse + +__all__ = ["SpansResource", "AsyncSpansResource"] + + +class SpansResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> SpansResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return SpansResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> SpansResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return SpansResourceWithStreamingResponse(self) + + def create( + self, + *, + name: str, + start_time: Union[str, datetime], + trace_id: str, + id: Optional[str] | NotGiven = NOT_GIVEN, + data: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, + end_time: Union[str, datetime, None] | NotGiven = NOT_GIVEN, + input: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, + output: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, + parent_id: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> Span: + """ + Create a new span with the provided parameters + + Args: + name: Name that describes what operation this span represents + + start_time: The time the span started + + trace_id: Unique identifier for the trace this span belongs to + + id: Unique identifier for the span. If not provided, an ID will be generated. + + data: Any additional metadata or context for the span + + end_time: The time the span ended + + input: Input parameters or data for the operation + + output: Output data resulting from the operation + + parent_id: ID of the parent span if this is a child span in a trace + + 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 + """ + return self._post( + "/spans", + body=maybe_transform( + { + "name": name, + "start_time": start_time, + "trace_id": trace_id, + "id": id, + "data": data, + "end_time": end_time, + "input": input, + "output": output, + "parent_id": parent_id, + }, + span_create_params.SpanCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Span, + ) + + def retrieve( + self, + span_id: str, + *, + # 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, + ) -> Span: + """ + Get a span by ID + + Args: + 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 + """ + if not span_id: + raise ValueError(f"Expected a non-empty value for `span_id` but received {span_id!r}") + return self._get( + f"/spans/{span_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Span, + ) + + def update( + self, + span_id: str, + *, + data: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, + end_time: Union[str, datetime, None] | NotGiven = NOT_GIVEN, + input: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, + name: Optional[str] | NotGiven = NOT_GIVEN, + output: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, + parent_id: Optional[str] | NotGiven = NOT_GIVEN, + start_time: Union[str, datetime, None] | NotGiven = NOT_GIVEN, + trace_id: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> Span: + """ + Update a span with the provided output data and mark it as complete + + Args: + data: Any additional metadata or context for the span + + end_time: The time the span ended + + input: Input parameters or data for the operation + + name: Name that describes what operation this span represents + + output: Output data resulting from the operation + + parent_id: ID of the parent span if this is a child span in a trace + + start_time: The time the span started + + trace_id: Unique identifier for the trace this span belongs to + + 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 + """ + if not span_id: + raise ValueError(f"Expected a non-empty value for `span_id` but received {span_id!r}") + return self._patch( + f"/spans/{span_id}", + body=maybe_transform( + { + "data": data, + "end_time": end_time, + "input": input, + "name": name, + "output": output, + "parent_id": parent_id, + "start_time": start_time, + "trace_id": trace_id, + }, + span_update_params.SpanUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Span, + ) + + def list( + self, + *, + trace_id: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> SpanListResponse: + """ + List all spans for a given trace ID + + Args: + 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 + """ + return self._get( + "/spans", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform({"trace_id": trace_id}, span_list_params.SpanListParams), + ), + cast_to=SpanListResponse, + ) + + +class AsyncSpansResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncSpansResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncSpansResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncSpansResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return AsyncSpansResourceWithStreamingResponse(self) + + async def create( + self, + *, + name: str, + start_time: Union[str, datetime], + trace_id: str, + id: Optional[str] | NotGiven = NOT_GIVEN, + data: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, + end_time: Union[str, datetime, None] | NotGiven = NOT_GIVEN, + input: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, + output: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, + parent_id: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> Span: + """ + Create a new span with the provided parameters + + Args: + name: Name that describes what operation this span represents + + start_time: The time the span started + + trace_id: Unique identifier for the trace this span belongs to + + id: Unique identifier for the span. If not provided, an ID will be generated. + + data: Any additional metadata or context for the span + + end_time: The time the span ended + + input: Input parameters or data for the operation + + output: Output data resulting from the operation + + parent_id: ID of the parent span if this is a child span in a trace + + 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 + """ + return await self._post( + "/spans", + body=await async_maybe_transform( + { + "name": name, + "start_time": start_time, + "trace_id": trace_id, + "id": id, + "data": data, + "end_time": end_time, + "input": input, + "output": output, + "parent_id": parent_id, + }, + span_create_params.SpanCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Span, + ) + + async def retrieve( + self, + span_id: str, + *, + # 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, + ) -> Span: + """ + Get a span by ID + + Args: + 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 + """ + if not span_id: + raise ValueError(f"Expected a non-empty value for `span_id` but received {span_id!r}") + return await self._get( + f"/spans/{span_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Span, + ) + + async def update( + self, + span_id: str, + *, + data: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, + end_time: Union[str, datetime, None] | NotGiven = NOT_GIVEN, + input: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, + name: Optional[str] | NotGiven = NOT_GIVEN, + output: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, + parent_id: Optional[str] | NotGiven = NOT_GIVEN, + start_time: Union[str, datetime, None] | NotGiven = NOT_GIVEN, + trace_id: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> Span: + """ + Update a span with the provided output data and mark it as complete + + Args: + data: Any additional metadata or context for the span + + end_time: The time the span ended + + input: Input parameters or data for the operation + + name: Name that describes what operation this span represents + + output: Output data resulting from the operation + + parent_id: ID of the parent span if this is a child span in a trace + + start_time: The time the span started + + trace_id: Unique identifier for the trace this span belongs to + + 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 + """ + if not span_id: + raise ValueError(f"Expected a non-empty value for `span_id` but received {span_id!r}") + return await self._patch( + f"/spans/{span_id}", + body=await async_maybe_transform( + { + "data": data, + "end_time": end_time, + "input": input, + "name": name, + "output": output, + "parent_id": parent_id, + "start_time": start_time, + "trace_id": trace_id, + }, + span_update_params.SpanUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Span, + ) + + async def list( + self, + *, + trace_id: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> SpanListResponse: + """ + List all spans for a given trace ID + + Args: + 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 + """ + return await self._get( + "/spans", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform({"trace_id": trace_id}, span_list_params.SpanListParams), + ), + cast_to=SpanListResponse, + ) + + +class SpansResourceWithRawResponse: + def __init__(self, spans: SpansResource) -> None: + self._spans = spans + + self.create = to_raw_response_wrapper( + spans.create, + ) + self.retrieve = to_raw_response_wrapper( + spans.retrieve, + ) + self.update = to_raw_response_wrapper( + spans.update, + ) + self.list = to_raw_response_wrapper( + spans.list, + ) + + +class AsyncSpansResourceWithRawResponse: + def __init__(self, spans: AsyncSpansResource) -> None: + self._spans = spans + + self.create = async_to_raw_response_wrapper( + spans.create, + ) + self.retrieve = async_to_raw_response_wrapper( + spans.retrieve, + ) + self.update = async_to_raw_response_wrapper( + spans.update, + ) + self.list = async_to_raw_response_wrapper( + spans.list, + ) + + +class SpansResourceWithStreamingResponse: + def __init__(self, spans: SpansResource) -> None: + self._spans = spans + + self.create = to_streamed_response_wrapper( + spans.create, + ) + self.retrieve = to_streamed_response_wrapper( + spans.retrieve, + ) + self.update = to_streamed_response_wrapper( + spans.update, + ) + self.list = to_streamed_response_wrapper( + spans.list, + ) + + +class AsyncSpansResourceWithStreamingResponse: + def __init__(self, spans: AsyncSpansResource) -> None: + self._spans = spans + + self.create = async_to_streamed_response_wrapper( + spans.create, + ) + self.retrieve = async_to_streamed_response_wrapper( + spans.retrieve, + ) + self.update = async_to_streamed_response_wrapper( + spans.update, + ) + self.list = async_to_streamed_response_wrapper( + spans.list, + ) diff --git a/src/agentex_sdk/resources/states.py b/src/agentex_sdk/resources/states.py new file mode 100644 index 00000000..84a0a1de --- /dev/null +++ b/src/agentex_sdk/resources/states.py @@ -0,0 +1,544 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict, Optional + +import httpx + +from ..types import state_list_params, state_create_params, state_update_params +from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._utils import maybe_transform, async_maybe_transform +from .._compat import cached_property +from .._resource import SyncAPIResource, AsyncAPIResource +from .._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ..types.state import State +from .._base_client import make_request_options +from ..types.state_list_response import StateListResponse + +__all__ = ["StatesResource", "AsyncStatesResource"] + + +class StatesResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> StatesResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return StatesResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> StatesResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return StatesResourceWithStreamingResponse(self) + + def create( + self, + *, + agent_id: str, + state: Dict[str, object], + task_id: str, + # 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, + ) -> State: + """ + Create Task State + + Args: + 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 + """ + return self._post( + "/states", + body=maybe_transform( + { + "agent_id": agent_id, + "state": state, + "task_id": task_id, + }, + state_create_params.StateCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=State, + ) + + def retrieve( + self, + state_id: str, + *, + # 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, + ) -> State: + """ + Get a state by its unique state ID. + + Args: + 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 + """ + if not state_id: + raise ValueError(f"Expected a non-empty value for `state_id` but received {state_id!r}") + return self._get( + f"/states/{state_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=State, + ) + + def update( + self, + state_id: str, + *, + agent_id: str, + state: Dict[str, object], + task_id: str, + # 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, + ) -> State: + """ + Update Task State + + Args: + 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 + """ + if not state_id: + raise ValueError(f"Expected a non-empty value for `state_id` but received {state_id!r}") + return self._put( + f"/states/{state_id}", + body=maybe_transform( + { + "agent_id": agent_id, + "state": state, + "task_id": task_id, + }, + state_update_params.StateUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=State, + ) + + def list( + self, + *, + agent_id: Optional[str] | NotGiven = NOT_GIVEN, + task_id: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> StateListResponse: + """ + List all states, optionally filtered by query parameters. + + Args: + agent_id: Agent ID + + task_id: Task ID + + 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 + """ + return self._get( + "/states", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "agent_id": agent_id, + "task_id": task_id, + }, + state_list_params.StateListParams, + ), + ), + cast_to=StateListResponse, + ) + + def delete( + self, + state_id: str, + *, + # 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, + ) -> State: + """ + Delete Task State + + Args: + 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 + """ + if not state_id: + raise ValueError(f"Expected a non-empty value for `state_id` but received {state_id!r}") + return self._delete( + f"/states/{state_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=State, + ) + + +class AsyncStatesResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncStatesResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncStatesResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncStatesResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return AsyncStatesResourceWithStreamingResponse(self) + + async def create( + self, + *, + agent_id: str, + state: Dict[str, object], + task_id: str, + # 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, + ) -> State: + """ + Create Task State + + Args: + 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 + """ + return await self._post( + "/states", + body=await async_maybe_transform( + { + "agent_id": agent_id, + "state": state, + "task_id": task_id, + }, + state_create_params.StateCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=State, + ) + + async def retrieve( + self, + state_id: str, + *, + # 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, + ) -> State: + """ + Get a state by its unique state ID. + + Args: + 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 + """ + if not state_id: + raise ValueError(f"Expected a non-empty value for `state_id` but received {state_id!r}") + return await self._get( + f"/states/{state_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=State, + ) + + async def update( + self, + state_id: str, + *, + agent_id: str, + state: Dict[str, object], + task_id: str, + # 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, + ) -> State: + """ + Update Task State + + Args: + 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 + """ + if not state_id: + raise ValueError(f"Expected a non-empty value for `state_id` but received {state_id!r}") + return await self._put( + f"/states/{state_id}", + body=await async_maybe_transform( + { + "agent_id": agent_id, + "state": state, + "task_id": task_id, + }, + state_update_params.StateUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=State, + ) + + async def list( + self, + *, + agent_id: Optional[str] | NotGiven = NOT_GIVEN, + task_id: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> StateListResponse: + """ + List all states, optionally filtered by query parameters. + + Args: + agent_id: Agent ID + + task_id: Task ID + + 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 + """ + return await self._get( + "/states", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "agent_id": agent_id, + "task_id": task_id, + }, + state_list_params.StateListParams, + ), + ), + cast_to=StateListResponse, + ) + + async def delete( + self, + state_id: str, + *, + # 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, + ) -> State: + """ + Delete Task State + + Args: + 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 + """ + if not state_id: + raise ValueError(f"Expected a non-empty value for `state_id` but received {state_id!r}") + return await self._delete( + f"/states/{state_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=State, + ) + + +class StatesResourceWithRawResponse: + def __init__(self, states: StatesResource) -> None: + self._states = states + + self.create = to_raw_response_wrapper( + states.create, + ) + self.retrieve = to_raw_response_wrapper( + states.retrieve, + ) + self.update = to_raw_response_wrapper( + states.update, + ) + self.list = to_raw_response_wrapper( + states.list, + ) + self.delete = to_raw_response_wrapper( + states.delete, + ) + + +class AsyncStatesResourceWithRawResponse: + def __init__(self, states: AsyncStatesResource) -> None: + self._states = states + + self.create = async_to_raw_response_wrapper( + states.create, + ) + self.retrieve = async_to_raw_response_wrapper( + states.retrieve, + ) + self.update = async_to_raw_response_wrapper( + states.update, + ) + self.list = async_to_raw_response_wrapper( + states.list, + ) + self.delete = async_to_raw_response_wrapper( + states.delete, + ) + + +class StatesResourceWithStreamingResponse: + def __init__(self, states: StatesResource) -> None: + self._states = states + + self.create = to_streamed_response_wrapper( + states.create, + ) + self.retrieve = to_streamed_response_wrapper( + states.retrieve, + ) + self.update = to_streamed_response_wrapper( + states.update, + ) + self.list = to_streamed_response_wrapper( + states.list, + ) + self.delete = to_streamed_response_wrapper( + states.delete, + ) + + +class AsyncStatesResourceWithStreamingResponse: + def __init__(self, states: AsyncStatesResource) -> None: + self._states = states + + self.create = async_to_streamed_response_wrapper( + states.create, + ) + self.retrieve = async_to_streamed_response_wrapper( + states.retrieve, + ) + self.update = async_to_streamed_response_wrapper( + states.update, + ) + self.list = async_to_streamed_response_wrapper( + states.list, + ) + self.delete = async_to_streamed_response_wrapper( + states.delete, + ) diff --git a/src/agentex_sdk/resources/tasks/__init__.py b/src/agentex_sdk/resources/tasks/__init__.py new file mode 100644 index 00000000..5a9c81b0 --- /dev/null +++ b/src/agentex_sdk/resources/tasks/__init__.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .name import ( + NameResource, + AsyncNameResource, + NameResourceWithRawResponse, + AsyncNameResourceWithRawResponse, + NameResourceWithStreamingResponse, + AsyncNameResourceWithStreamingResponse, +) +from .tasks import ( + TasksResource, + AsyncTasksResource, + TasksResourceWithRawResponse, + AsyncTasksResourceWithRawResponse, + TasksResourceWithStreamingResponse, + AsyncTasksResourceWithStreamingResponse, +) + +__all__ = [ + "NameResource", + "AsyncNameResource", + "NameResourceWithRawResponse", + "AsyncNameResourceWithRawResponse", + "NameResourceWithStreamingResponse", + "AsyncNameResourceWithStreamingResponse", + "TasksResource", + "AsyncTasksResource", + "TasksResourceWithRawResponse", + "AsyncTasksResourceWithRawResponse", + "TasksResourceWithStreamingResponse", + "AsyncTasksResourceWithStreamingResponse", +] diff --git a/src/agentex_sdk/resources/tasks/name.py b/src/agentex_sdk/resources/tasks/name.py new file mode 100644 index 00000000..cec79c27 --- /dev/null +++ b/src/agentex_sdk/resources/tasks/name.py @@ -0,0 +1,324 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import httpx + +from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ..._streaming import Stream, AsyncStream +from ...types.task import Task +from ..._base_client import make_request_options + +__all__ = ["NameResource", "AsyncNameResource"] + + +class NameResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> NameResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return NameResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> NameResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return NameResourceWithStreamingResponse(self) + + def retrieve( + self, + task_name: str, + *, + # 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, + ) -> Task: + """ + Get a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return self._get( + f"/tasks/name/{task_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + + def delete( + self, + task_name: str, + *, + # 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, + ) -> Task: + """ + Delete a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return self._delete( + f"/tasks/name/{task_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + + def stream_events( + self, + task_name: str, + *, + # 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, + ) -> Stream[object]: + """ + Stream events for a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return self._get( + f"/tasks/name/{task_name}/stream", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + stream=True, + stream_cls=Stream[object], + ) + + +class AsyncNameResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncNameResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncNameResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncNameResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return AsyncNameResourceWithStreamingResponse(self) + + async def retrieve( + self, + task_name: str, + *, + # 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, + ) -> Task: + """ + Get a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return await self._get( + f"/tasks/name/{task_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + + async def delete( + self, + task_name: str, + *, + # 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, + ) -> Task: + """ + Delete a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return await self._delete( + f"/tasks/name/{task_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + + async def stream_events( + self, + task_name: str, + *, + # 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, + ) -> AsyncStream[object]: + """ + Stream events for a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return await self._get( + f"/tasks/name/{task_name}/stream", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + stream=True, + stream_cls=AsyncStream[object], + ) + + +class NameResourceWithRawResponse: + def __init__(self, name: NameResource) -> None: + self._name = name + + self.retrieve = to_raw_response_wrapper( + name.retrieve, + ) + self.delete = to_raw_response_wrapper( + name.delete, + ) + self.stream_events = to_raw_response_wrapper( + name.stream_events, + ) + + +class AsyncNameResourceWithRawResponse: + def __init__(self, name: AsyncNameResource) -> None: + self._name = name + + self.retrieve = async_to_raw_response_wrapper( + name.retrieve, + ) + self.delete = async_to_raw_response_wrapper( + name.delete, + ) + self.stream_events = async_to_raw_response_wrapper( + name.stream_events, + ) + + +class NameResourceWithStreamingResponse: + def __init__(self, name: NameResource) -> None: + self._name = name + + self.retrieve = to_streamed_response_wrapper( + name.retrieve, + ) + self.delete = to_streamed_response_wrapper( + name.delete, + ) + self.stream_events = to_streamed_response_wrapper( + name.stream_events, + ) + + +class AsyncNameResourceWithStreamingResponse: + def __init__(self, name: AsyncNameResource) -> None: + self._name = name + + self.retrieve = async_to_streamed_response_wrapper( + name.retrieve, + ) + self.delete = async_to_streamed_response_wrapper( + name.delete, + ) + self.stream_events = async_to_streamed_response_wrapper( + name.stream_events, + ) diff --git a/src/agentex_sdk/resources/tasks/tasks.py b/src/agentex_sdk/resources/tasks/tasks.py new file mode 100644 index 00000000..b73374e4 --- /dev/null +++ b/src/agentex_sdk/resources/tasks/tasks.py @@ -0,0 +1,407 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import httpx + +from .name import ( + NameResource, + AsyncNameResource, + NameResourceWithRawResponse, + AsyncNameResourceWithRawResponse, + NameResourceWithStreamingResponse, + AsyncNameResourceWithStreamingResponse, +) +from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ..._streaming import Stream, AsyncStream +from ...types.task import Task +from ..._base_client import make_request_options +from ...types.task_list_response import TaskListResponse + +__all__ = ["TasksResource", "AsyncTasksResource"] + + +class TasksResource(SyncAPIResource): + @cached_property + def name(self) -> NameResource: + return NameResource(self._client) + + @cached_property + def with_raw_response(self) -> TasksResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return TasksResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> TasksResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return TasksResourceWithStreamingResponse(self) + + def retrieve( + self, + task_id: str, + *, + # 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, + ) -> Task: + """ + Get a task by its unique ID. + + Args: + 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 + """ + if not task_id: + raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}") + return self._get( + f"/tasks/{task_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + + def list( + self, + *, + # 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, + ) -> TaskListResponse: + """List all tasks.""" + return self._get( + "/tasks", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=TaskListResponse, + ) + + def delete( + self, + task_id: str, + *, + # 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, + ) -> Task: + """ + Delete a task by its unique ID. + + Args: + 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 + """ + if not task_id: + raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}") + return self._delete( + f"/tasks/{task_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + + def stream_events( + self, + task_id: str, + *, + # 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, + ) -> Stream[object]: + """ + Stream events for a task by its unique ID. + + Args: + 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 + """ + if not task_id: + raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}") + return self._get( + f"/tasks/{task_id}/stream", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + stream=True, + stream_cls=Stream[object], + ) + + +class AsyncTasksResource(AsyncAPIResource): + @cached_property + def name(self) -> AsyncNameResource: + return AsyncNameResource(self._client) + + @cached_property + def with_raw_response(self) -> AsyncTasksResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncTasksResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncTasksResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return AsyncTasksResourceWithStreamingResponse(self) + + async def retrieve( + self, + task_id: str, + *, + # 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, + ) -> Task: + """ + Get a task by its unique ID. + + Args: + 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 + """ + if not task_id: + raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}") + return await self._get( + f"/tasks/{task_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + + async def list( + self, + *, + # 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, + ) -> TaskListResponse: + """List all tasks.""" + return await self._get( + "/tasks", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=TaskListResponse, + ) + + async def delete( + self, + task_id: str, + *, + # 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, + ) -> Task: + """ + Delete a task by its unique ID. + + Args: + 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 + """ + if not task_id: + raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}") + return await self._delete( + f"/tasks/{task_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + + async def stream_events( + self, + task_id: str, + *, + # 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, + ) -> AsyncStream[object]: + """ + Stream events for a task by its unique ID. + + Args: + 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 + """ + if not task_id: + raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}") + return await self._get( + f"/tasks/{task_id}/stream", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + stream=True, + stream_cls=AsyncStream[object], + ) + + +class TasksResourceWithRawResponse: + def __init__(self, tasks: TasksResource) -> None: + self._tasks = tasks + + self.retrieve = to_raw_response_wrapper( + tasks.retrieve, + ) + self.list = to_raw_response_wrapper( + tasks.list, + ) + self.delete = to_raw_response_wrapper( + tasks.delete, + ) + self.stream_events = to_raw_response_wrapper( + tasks.stream_events, + ) + + @cached_property + def name(self) -> NameResourceWithRawResponse: + return NameResourceWithRawResponse(self._tasks.name) + + +class AsyncTasksResourceWithRawResponse: + def __init__(self, tasks: AsyncTasksResource) -> None: + self._tasks = tasks + + self.retrieve = async_to_raw_response_wrapper( + tasks.retrieve, + ) + self.list = async_to_raw_response_wrapper( + tasks.list, + ) + self.delete = async_to_raw_response_wrapper( + tasks.delete, + ) + self.stream_events = async_to_raw_response_wrapper( + tasks.stream_events, + ) + + @cached_property + def name(self) -> AsyncNameResourceWithRawResponse: + return AsyncNameResourceWithRawResponse(self._tasks.name) + + +class TasksResourceWithStreamingResponse: + def __init__(self, tasks: TasksResource) -> None: + self._tasks = tasks + + self.retrieve = to_streamed_response_wrapper( + tasks.retrieve, + ) + self.list = to_streamed_response_wrapper( + tasks.list, + ) + self.delete = to_streamed_response_wrapper( + tasks.delete, + ) + self.stream_events = to_streamed_response_wrapper( + tasks.stream_events, + ) + + @cached_property + def name(self) -> NameResourceWithStreamingResponse: + return NameResourceWithStreamingResponse(self._tasks.name) + + +class AsyncTasksResourceWithStreamingResponse: + def __init__(self, tasks: AsyncTasksResource) -> None: + self._tasks = tasks + + self.retrieve = async_to_streamed_response_wrapper( + tasks.retrieve, + ) + self.list = async_to_streamed_response_wrapper( + tasks.list, + ) + self.delete = async_to_streamed_response_wrapper( + tasks.delete, + ) + self.stream_events = async_to_streamed_response_wrapper( + tasks.stream_events, + ) + + @cached_property + def name(self) -> AsyncNameResourceWithStreamingResponse: + return AsyncNameResourceWithStreamingResponse(self._tasks.name) diff --git a/src/agentex_sdk/resources/tracker.py b/src/agentex_sdk/resources/tracker.py new file mode 100644 index 00000000..f6236903 --- /dev/null +++ b/src/agentex_sdk/resources/tracker.py @@ -0,0 +1,384 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional + +import httpx + +from ..types import tracker_list_params, tracker_update_params +from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._utils import maybe_transform, async_maybe_transform +from .._compat import cached_property +from .._resource import SyncAPIResource, AsyncAPIResource +from .._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from .._base_client import make_request_options +from ..types.agent_task_tracker import AgentTaskTracker +from ..types.tracker_list_response import TrackerListResponse + +__all__ = ["TrackerResource", "AsyncTrackerResource"] + + +class TrackerResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> TrackerResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return TrackerResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> TrackerResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return TrackerResourceWithStreamingResponse(self) + + def retrieve( + self, + tracker_id: str, + *, + # 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, + ) -> AgentTaskTracker: + """ + Get agent task tracker by tracker ID + + Args: + 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 + """ + if not tracker_id: + raise ValueError(f"Expected a non-empty value for `tracker_id` but received {tracker_id!r}") + return self._get( + f"/tracker/{tracker_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AgentTaskTracker, + ) + + def update( + self, + tracker_id: str, + *, + last_processed_event_id: Optional[str] | NotGiven = NOT_GIVEN, + status: Optional[str] | NotGiven = NOT_GIVEN, + status_reason: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> AgentTaskTracker: + """ + Update agent task tracker by tracker ID + + Args: + last_processed_event_id: The most recent processed event ID (omit to leave unchanged) + + status: Processing status + + status_reason: Optional status reason + + 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 + """ + if not tracker_id: + raise ValueError(f"Expected a non-empty value for `tracker_id` but received {tracker_id!r}") + return self._put( + f"/tracker/{tracker_id}", + body=maybe_transform( + { + "last_processed_event_id": last_processed_event_id, + "status": status, + "status_reason": status_reason, + }, + tracker_update_params.TrackerUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AgentTaskTracker, + ) + + def list( + self, + *, + agent_id: Optional[str] | NotGiven = NOT_GIVEN, + task_id: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> TrackerListResponse: + """ + List all agent task trackers, optionally filtered by query parameters. + + Args: + agent_id: Agent ID + + task_id: Task ID + + 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 + """ + return self._get( + "/tracker", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "agent_id": agent_id, + "task_id": task_id, + }, + tracker_list_params.TrackerListParams, + ), + ), + cast_to=TrackerListResponse, + ) + + +class AsyncTrackerResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncTrackerResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncTrackerResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncTrackerResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + """ + return AsyncTrackerResourceWithStreamingResponse(self) + + async def retrieve( + self, + tracker_id: str, + *, + # 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, + ) -> AgentTaskTracker: + """ + Get agent task tracker by tracker ID + + Args: + 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 + """ + if not tracker_id: + raise ValueError(f"Expected a non-empty value for `tracker_id` but received {tracker_id!r}") + return await self._get( + f"/tracker/{tracker_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AgentTaskTracker, + ) + + async def update( + self, + tracker_id: str, + *, + last_processed_event_id: Optional[str] | NotGiven = NOT_GIVEN, + status: Optional[str] | NotGiven = NOT_GIVEN, + status_reason: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> AgentTaskTracker: + """ + Update agent task tracker by tracker ID + + Args: + last_processed_event_id: The most recent processed event ID (omit to leave unchanged) + + status: Processing status + + status_reason: Optional status reason + + 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 + """ + if not tracker_id: + raise ValueError(f"Expected a non-empty value for `tracker_id` but received {tracker_id!r}") + return await self._put( + f"/tracker/{tracker_id}", + body=await async_maybe_transform( + { + "last_processed_event_id": last_processed_event_id, + "status": status, + "status_reason": status_reason, + }, + tracker_update_params.TrackerUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AgentTaskTracker, + ) + + async def list( + self, + *, + agent_id: Optional[str] | NotGiven = NOT_GIVEN, + task_id: Optional[str] | NotGiven = NOT_GIVEN, + # 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, + ) -> TrackerListResponse: + """ + List all agent task trackers, optionally filtered by query parameters. + + Args: + agent_id: Agent ID + + task_id: Task ID + + 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 + """ + return await self._get( + "/tracker", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "agent_id": agent_id, + "task_id": task_id, + }, + tracker_list_params.TrackerListParams, + ), + ), + cast_to=TrackerListResponse, + ) + + +class TrackerResourceWithRawResponse: + def __init__(self, tracker: TrackerResource) -> None: + self._tracker = tracker + + self.retrieve = to_raw_response_wrapper( + tracker.retrieve, + ) + self.update = to_raw_response_wrapper( + tracker.update, + ) + self.list = to_raw_response_wrapper( + tracker.list, + ) + + +class AsyncTrackerResourceWithRawResponse: + def __init__(self, tracker: AsyncTrackerResource) -> None: + self._tracker = tracker + + self.retrieve = async_to_raw_response_wrapper( + tracker.retrieve, + ) + self.update = async_to_raw_response_wrapper( + tracker.update, + ) + self.list = async_to_raw_response_wrapper( + tracker.list, + ) + + +class TrackerResourceWithStreamingResponse: + def __init__(self, tracker: TrackerResource) -> None: + self._tracker = tracker + + self.retrieve = to_streamed_response_wrapper( + tracker.retrieve, + ) + self.update = to_streamed_response_wrapper( + tracker.update, + ) + self.list = to_streamed_response_wrapper( + tracker.list, + ) + + +class AsyncTrackerResourceWithStreamingResponse: + def __init__(self, tracker: AsyncTrackerResource) -> None: + self._tracker = tracker + + self.retrieve = async_to_streamed_response_wrapper( + tracker.retrieve, + ) + self.update = async_to_streamed_response_wrapper( + tracker.update, + ) + self.list = async_to_streamed_response_wrapper( + tracker.list, + ) diff --git a/src/agentex_sdk/types/__init__.py b/src/agentex_sdk/types/__init__.py new file mode 100644 index 00000000..12a40c1b --- /dev/null +++ b/src/agentex_sdk/types/__init__.py @@ -0,0 +1,45 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from .span import Span as Span +from .task import Task as Task +from .agent import Agent as Agent +from .event import Event as Event +from .state import State as State +from .acp_type import AcpType as AcpType +from .data_content import DataContent as DataContent +from .task_message import TaskMessage as TaskMessage +from .text_content import TextContent as TextContent +from .message_style import MessageStyle as MessageStyle +from .message_author import MessageAuthor as MessageAuthor +from .echo_send_params import EchoSendParams as EchoSendParams +from .span_list_params import SpanListParams as SpanListParams +from .streaming_status import StreamingStatus as StreamingStatus +from .agent_list_params import AgentListParams as AgentListParams +from .event_list_params import EventListParams as EventListParams +from .state_list_params import StateListParams as StateListParams +from .agent_task_tracker import AgentTaskTracker as AgentTaskTracker +from .data_content_param import DataContentParam as DataContentParam +from .span_create_params import SpanCreateParams as SpanCreateParams +from .span_list_response import SpanListResponse as SpanListResponse +from .span_update_params import SpanUpdateParams as SpanUpdateParams +from .task_list_response import TaskListResponse as TaskListResponse +from .text_content_param import TextContentParam as TextContentParam +from .agent_list_response import AgentListResponse as AgentListResponse +from .event_list_response import EventListResponse as EventListResponse +from .message_list_params import MessageListParams as MessageListParams +from .state_create_params import StateCreateParams as StateCreateParams +from .state_list_response import StateListResponse as StateListResponse +from .state_update_params import StateUpdateParams as StateUpdateParams +from .tracker_list_params import TrackerListParams as TrackerListParams +from .tool_request_content import ToolRequestContent as ToolRequestContent +from .agent_register_params import AgentRegisterParams as AgentRegisterParams +from .message_create_params import MessageCreateParams as MessageCreateParams +from .message_list_response import MessageListResponse as MessageListResponse +from .message_update_params import MessageUpdateParams as MessageUpdateParams +from .tool_response_content import ToolResponseContent as ToolResponseContent +from .tracker_list_response import TrackerListResponse as TrackerListResponse +from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams +from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam diff --git a/src/agentex_sdk/types/acp_type.py b/src/agentex_sdk/types/acp_type.py new file mode 100644 index 00000000..ec86ddf5 --- /dev/null +++ b/src/agentex_sdk/types/acp_type.py @@ -0,0 +1,7 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing_extensions import Literal, TypeAlias + +__all__ = ["AcpType"] + +AcpType: TypeAlias = Literal["sync", "agentic"] diff --git a/src/agentex_sdk/types/agent.py b/src/agentex_sdk/types/agent.py new file mode 100644 index 00000000..d339ece1 --- /dev/null +++ b/src/agentex_sdk/types/agent.py @@ -0,0 +1,29 @@ +# 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 +from .acp_type import AcpType + +__all__ = ["Agent"] + + +class Agent(BaseModel): + id: str + """The unique identifier of the agent.""" + + acp_type: AcpType + """The type of the ACP Server (Either sync or agentic)""" + + description: str + """The description of the action.""" + + name: str + """The unique name of the agent.""" + + status: Optional[Literal["Pending", "Building", "Ready", "Failed", "Unknown"]] = None + """The status of the action, indicating if it's building, ready, failed, etc.""" + + status_reason: Optional[str] = None + """The reason for the status of the action.""" diff --git a/src/agentex_sdk/types/agent_list_params.py b/src/agentex_sdk/types/agent_list_params.py new file mode 100644 index 00000000..b432174a --- /dev/null +++ b/src/agentex_sdk/types/agent_list_params.py @@ -0,0 +1,13 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import TypedDict + +__all__ = ["AgentListParams"] + + +class AgentListParams(TypedDict, total=False): + task_id: Optional[str] + """Task ID""" diff --git a/src/agentex_sdk/types/agent_list_response.py b/src/agentex_sdk/types/agent_list_response.py new file mode 100644 index 00000000..f33d2016 --- /dev/null +++ b/src/agentex_sdk/types/agent_list_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from .agent import Agent + +__all__ = ["AgentListResponse"] + +AgentListResponse: TypeAlias = List[Agent] diff --git a/src/agentex_sdk/types/agent_register_params.py b/src/agentex_sdk/types/agent_register_params.py new file mode 100644 index 00000000..9b8b6dd3 --- /dev/null +++ b/src/agentex_sdk/types/agent_register_params.py @@ -0,0 +1,27 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Required, TypedDict + +from .acp_type import AcpType + +__all__ = ["AgentRegisterParams"] + + +class AgentRegisterParams(TypedDict, total=False): + acp_type: Required[AcpType] + """The type of ACP to use for the agent.""" + + acp_url: Required[str] + """The URL of the ACP server for the agent.""" + + description: Required[str] + """The description of the agent.""" + + name: Required[str] + """The unique name of the agent.""" + + agent_id: Optional[str] + """Optional agent ID if the agent already exists and needs to be updated.""" diff --git a/src/agentex_sdk/types/agent_task_tracker.py b/src/agentex_sdk/types/agent_task_tracker.py new file mode 100644 index 00000000..4f6ebaa7 --- /dev/null +++ b/src/agentex_sdk/types/agent_task_tracker.py @@ -0,0 +1,34 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional +from datetime import datetime + +from .._models import BaseModel + +__all__ = ["AgentTaskTracker"] + + +class AgentTaskTracker(BaseModel): + id: str + """The UUID of the agent task tracker""" + + agent_id: str + """The UUID of the agent""" + + created_at: datetime + """When the agent task tracker was created""" + + task_id: str + """The UUID of the task""" + + last_processed_event_id: Optional[str] = None + """The last processed event ID""" + + status: Optional[str] = None + """Processing status""" + + status_reason: Optional[str] = None + """Optional status reason""" + + updated_at: Optional[datetime] = None + """When the agent task tracker was last updated""" diff --git a/src/agentex_sdk/types/agents/__init__.py b/src/agentex_sdk/types/agents/__init__.py new file mode 100644 index 00000000..f8ee8b14 --- /dev/null +++ b/src/agentex_sdk/types/agents/__init__.py @@ -0,0 +1,3 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations diff --git a/src/agentex_sdk/types/data_content.py b/src/agentex_sdk/types/data_content.py new file mode 100644 index 00000000..2ed34045 --- /dev/null +++ b/src/agentex_sdk/types/data_content.py @@ -0,0 +1,30 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict, Optional +from typing_extensions import Literal + +from .._models import BaseModel +from .message_style import MessageStyle +from .message_author import MessageAuthor + +__all__ = ["DataContent"] + + +class DataContent(BaseModel): + author: MessageAuthor + """ + The role of the messages author, in this case `system`, `user`, `assistant`, or + `tool`. + """ + + data: Dict[str, object] + """The contents of the data message.""" + + style: Optional[MessageStyle] = None + """The style of the message. + + This is used by the client to determine how to display the message. + """ + + type: Optional[Literal["data"]] = None + """The type of the message, in this case `data`.""" diff --git a/src/agentex_sdk/types/data_content_param.py b/src/agentex_sdk/types/data_content_param.py new file mode 100644 index 00000000..2232e417 --- /dev/null +++ b/src/agentex_sdk/types/data_content_param.py @@ -0,0 +1,31 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict +from typing_extensions import Literal, Required, TypedDict + +from .message_style import MessageStyle +from .message_author import MessageAuthor + +__all__ = ["DataContentParam"] + + +class DataContentParam(TypedDict, total=False): + author: Required[MessageAuthor] + """ + The role of the messages author, in this case `system`, `user`, `assistant`, or + `tool`. + """ + + data: Required[Dict[str, object]] + """The contents of the data message.""" + + style: MessageStyle + """The style of the message. + + This is used by the client to determine how to display the message. + """ + + type: Literal["data"] + """The type of the message, in this case `data`.""" diff --git a/src/agentex_sdk/types/echo_send_params.py b/src/agentex_sdk/types/echo_send_params.py new file mode 100644 index 00000000..3e237817 --- /dev/null +++ b/src/agentex_sdk/types/echo_send_params.py @@ -0,0 +1,11 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +__all__ = ["EchoSendParams"] + + +class EchoSendParams(TypedDict, total=False): + message: Required[str] diff --git a/src/agentex_sdk/types/event.py b/src/agentex_sdk/types/event.py new file mode 100644 index 00000000..3f1e5997 --- /dev/null +++ b/src/agentex_sdk/types/event.py @@ -0,0 +1,38 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Union, Optional +from datetime import datetime +from typing_extensions import Annotated, TypeAlias + +from .._utils import PropertyInfo +from .._models import BaseModel +from .data_content import DataContent +from .text_content import TextContent +from .tool_request_content import ToolRequestContent +from .tool_response_content import ToolResponseContent + +__all__ = ["Event", "Content"] + +Content: TypeAlias = Annotated[ + Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent, None], PropertyInfo(discriminator="type") +] + + +class Event(BaseModel): + id: str + """The UUID of the event""" + + agent_id: str + """The UUID of the agent that the event belongs to""" + + sequence_id: int + """The sequence ID of the event""" + + task_id: str + """The UUID of the task that the event belongs to""" + + content: Optional[Content] = None + """The content of the event""" + + created_at: Optional[datetime] = None + """The timestamp of the event""" diff --git a/src/agentex_sdk/types/event_list_params.py b/src/agentex_sdk/types/event_list_params.py new file mode 100644 index 00000000..2d628dd6 --- /dev/null +++ b/src/agentex_sdk/types/event_list_params.py @@ -0,0 +1,22 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Required, TypedDict + +__all__ = ["EventListParams"] + + +class EventListParams(TypedDict, total=False): + agent_id: Required[str] + """The agent ID to filter events by""" + + task_id: Required[str] + """The task ID to filter events by""" + + last_processed_event_id: Optional[str] + """Optional event ID to get events after this ID""" + + limit: Optional[int] + """Optional limit on number of results""" diff --git a/src/agentex_sdk/types/event_list_response.py b/src/agentex_sdk/types/event_list_response.py new file mode 100644 index 00000000..05057180 --- /dev/null +++ b/src/agentex_sdk/types/event_list_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from .event import Event + +__all__ = ["EventListResponse"] + +EventListResponse: TypeAlias = List[Event] diff --git a/src/agentex_sdk/types/message_author.py b/src/agentex_sdk/types/message_author.py new file mode 100644 index 00000000..c902ac5e --- /dev/null +++ b/src/agentex_sdk/types/message_author.py @@ -0,0 +1,7 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing_extensions import Literal, TypeAlias + +__all__ = ["MessageAuthor"] + +MessageAuthor: TypeAlias = Literal["user", "agent"] diff --git a/src/agentex_sdk/types/message_create_params.py b/src/agentex_sdk/types/message_create_params.py new file mode 100644 index 00000000..06ec3727 --- /dev/null +++ b/src/agentex_sdk/types/message_create_params.py @@ -0,0 +1,25 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union, Optional +from typing_extensions import Required, TypeAlias, TypedDict + +from .streaming_status import StreamingStatus +from .data_content_param import DataContentParam +from .text_content_param import TextContentParam +from .tool_request_content_param import ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam + +__all__ = ["MessageCreateParams", "Content"] + + +class MessageCreateParams(TypedDict, total=False): + content: Required[Content] + + task_id: Required[str] + + streaming_status: Optional[StreamingStatus] + + +Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex_sdk/types/message_list_params.py b/src/agentex_sdk/types/message_list_params.py new file mode 100644 index 00000000..1bdcedb5 --- /dev/null +++ b/src/agentex_sdk/types/message_list_params.py @@ -0,0 +1,14 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Required, TypedDict + +__all__ = ["MessageListParams"] + + +class MessageListParams(TypedDict, total=False): + task_id: Required[str] + + limit: Optional[int] diff --git a/src/agentex_sdk/types/message_list_response.py b/src/agentex_sdk/types/message_list_response.py new file mode 100644 index 00000000..37123d90 --- /dev/null +++ b/src/agentex_sdk/types/message_list_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from .task_message import TaskMessage + +__all__ = ["MessageListResponse"] + +MessageListResponse: TypeAlias = List[TaskMessage] diff --git a/src/agentex_sdk/types/message_style.py b/src/agentex_sdk/types/message_style.py new file mode 100644 index 00000000..81520ffb --- /dev/null +++ b/src/agentex_sdk/types/message_style.py @@ -0,0 +1,7 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing_extensions import Literal, TypeAlias + +__all__ = ["MessageStyle"] + +MessageStyle: TypeAlias = Literal["static", "active"] diff --git a/src/agentex_sdk/types/message_update_params.py b/src/agentex_sdk/types/message_update_params.py new file mode 100644 index 00000000..bc5305b8 --- /dev/null +++ b/src/agentex_sdk/types/message_update_params.py @@ -0,0 +1,25 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union, Optional +from typing_extensions import Required, TypeAlias, TypedDict + +from .streaming_status import StreamingStatus +from .data_content_param import DataContentParam +from .text_content_param import TextContentParam +from .tool_request_content_param import ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam + +__all__ = ["MessageUpdateParams", "Content"] + + +class MessageUpdateParams(TypedDict, total=False): + content: Required[Content] + + task_id: Required[str] + + streaming_status: Optional[StreamingStatus] + + +Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex_sdk/types/messages/__init__.py b/src/agentex_sdk/types/messages/__init__.py new file mode 100644 index 00000000..00a2dde5 --- /dev/null +++ b/src/agentex_sdk/types/messages/__init__.py @@ -0,0 +1,8 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from .batch_create_params import BatchCreateParams as BatchCreateParams +from .batch_update_params import BatchUpdateParams as BatchUpdateParams +from .batch_create_response import BatchCreateResponse as BatchCreateResponse +from .batch_update_response import BatchUpdateResponse as BatchUpdateResponse diff --git a/src/agentex_sdk/types/messages/batch_create_params.py b/src/agentex_sdk/types/messages/batch_create_params.py new file mode 100644 index 00000000..c09c69a9 --- /dev/null +++ b/src/agentex_sdk/types/messages/batch_create_params.py @@ -0,0 +1,22 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union, Iterable +from typing_extensions import Required, TypeAlias, TypedDict + +from ..data_content_param import DataContentParam +from ..text_content_param import TextContentParam +from ..tool_request_content_param import ToolRequestContentParam +from ..tool_response_content_param import ToolResponseContentParam + +__all__ = ["BatchCreateParams", "Content"] + + +class BatchCreateParams(TypedDict, total=False): + contents: Required[Iterable[Content]] + + task_id: Required[str] + + +Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex_sdk/types/messages/batch_create_response.py b/src/agentex_sdk/types/messages/batch_create_response.py new file mode 100644 index 00000000..d110e3e3 --- /dev/null +++ b/src/agentex_sdk/types/messages/batch_create_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from ..task_message import TaskMessage + +__all__ = ["BatchCreateResponse"] + +BatchCreateResponse: TypeAlias = List[TaskMessage] diff --git a/src/agentex_sdk/types/messages/batch_update_params.py b/src/agentex_sdk/types/messages/batch_update_params.py new file mode 100644 index 00000000..68f24f8d --- /dev/null +++ b/src/agentex_sdk/types/messages/batch_update_params.py @@ -0,0 +1,22 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict, Union +from typing_extensions import Required, TypeAlias, TypedDict + +from ..data_content_param import DataContentParam +from ..text_content_param import TextContentParam +from ..tool_request_content_param import ToolRequestContentParam +from ..tool_response_content_param import ToolResponseContentParam + +__all__ = ["BatchUpdateParams", "Updates"] + + +class BatchUpdateParams(TypedDict, total=False): + task_id: Required[str] + + updates: Required[Dict[str, Updates]] + + +Updates: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex_sdk/types/messages/batch_update_response.py b/src/agentex_sdk/types/messages/batch_update_response.py new file mode 100644 index 00000000..12de8603 --- /dev/null +++ b/src/agentex_sdk/types/messages/batch_update_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from ..task_message import TaskMessage + +__all__ = ["BatchUpdateResponse"] + +BatchUpdateResponse: TypeAlias = List[TaskMessage] diff --git a/src/agentex_sdk/types/span.py b/src/agentex_sdk/types/span.py new file mode 100644 index 00000000..e5719bbe --- /dev/null +++ b/src/agentex_sdk/types/span.py @@ -0,0 +1,36 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict, List, Union, Optional +from datetime import datetime + +from .._models import BaseModel + +__all__ = ["Span"] + + +class Span(BaseModel): + id: str + + name: str + """Name that describes what operation this span represents""" + + start_time: datetime + """The time the span started""" + + trace_id: str + """Unique identifier for the trace this span belongs to""" + + data: Union[Dict[str, object], List[Dict[str, object]], None] = None + """Any additional metadata or context for the span""" + + end_time: Optional[datetime] = None + """The time the span ended""" + + input: Union[Dict[str, object], List[Dict[str, object]], None] = None + """Input parameters or data for the operation""" + + output: Union[Dict[str, object], List[Dict[str, object]], None] = None + """Output data resulting from the operation""" + + parent_id: Optional[str] = None + """ID of the parent span if this is a child span in a trace""" diff --git a/src/agentex_sdk/types/span_create_params.py b/src/agentex_sdk/types/span_create_params.py new file mode 100644 index 00000000..c7111d6f --- /dev/null +++ b/src/agentex_sdk/types/span_create_params.py @@ -0,0 +1,40 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict, Union, Iterable, Optional +from datetime import datetime +from typing_extensions import Required, Annotated, TypedDict + +from .._utils import PropertyInfo + +__all__ = ["SpanCreateParams"] + + +class SpanCreateParams(TypedDict, total=False): + name: Required[str] + """Name that describes what operation this span represents""" + + start_time: Required[Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]] + """The time the span started""" + + trace_id: Required[str] + """Unique identifier for the trace this span belongs to""" + + id: Optional[str] + """Unique identifier for the span. If not provided, an ID will be generated.""" + + data: Union[Dict[str, object], Iterable[Dict[str, object]], None] + """Any additional metadata or context for the span""" + + end_time: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")] + """The time the span ended""" + + input: Union[Dict[str, object], Iterable[Dict[str, object]], None] + """Input parameters or data for the operation""" + + output: Union[Dict[str, object], Iterable[Dict[str, object]], None] + """Output data resulting from the operation""" + + parent_id: Optional[str] + """ID of the parent span if this is a child span in a trace""" diff --git a/src/agentex_sdk/types/span_list_params.py b/src/agentex_sdk/types/span_list_params.py new file mode 100644 index 00000000..35218965 --- /dev/null +++ b/src/agentex_sdk/types/span_list_params.py @@ -0,0 +1,12 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import TypedDict + +__all__ = ["SpanListParams"] + + +class SpanListParams(TypedDict, total=False): + trace_id: Optional[str] diff --git a/src/agentex_sdk/types/span_list_response.py b/src/agentex_sdk/types/span_list_response.py new file mode 100644 index 00000000..12348665 --- /dev/null +++ b/src/agentex_sdk/types/span_list_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from .span import Span + +__all__ = ["SpanListResponse"] + +SpanListResponse: TypeAlias = List[Span] diff --git a/src/agentex_sdk/types/span_update_params.py b/src/agentex_sdk/types/span_update_params.py new file mode 100644 index 00000000..3ebb5465 --- /dev/null +++ b/src/agentex_sdk/types/span_update_params.py @@ -0,0 +1,37 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict, Union, Iterable, Optional +from datetime import datetime +from typing_extensions import Annotated, TypedDict + +from .._utils import PropertyInfo + +__all__ = ["SpanUpdateParams"] + + +class SpanUpdateParams(TypedDict, total=False): + data: Union[Dict[str, object], Iterable[Dict[str, object]], None] + """Any additional metadata or context for the span""" + + end_time: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")] + """The time the span ended""" + + input: Union[Dict[str, object], Iterable[Dict[str, object]], None] + """Input parameters or data for the operation""" + + name: Optional[str] + """Name that describes what operation this span represents""" + + output: Union[Dict[str, object], Iterable[Dict[str, object]], None] + """Output data resulting from the operation""" + + parent_id: Optional[str] + """ID of the parent span if this is a child span in a trace""" + + start_time: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")] + """The time the span started""" + + trace_id: Optional[str] + """Unique identifier for the trace this span belongs to""" diff --git a/src/agentex_sdk/types/state.py b/src/agentex_sdk/types/state.py new file mode 100644 index 00000000..2789c7c3 --- /dev/null +++ b/src/agentex_sdk/types/state.py @@ -0,0 +1,25 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict, Optional +from datetime import datetime + +from .._models import BaseModel + +__all__ = ["State"] + + +class State(BaseModel): + id: str + """The task state's unique id""" + + agent_id: str + + created_at: datetime + """The timestamp when the state was created""" + + state: Dict[str, object] + + task_id: str + + updated_at: Optional[datetime] = None + """The timestamp when the state was last updated""" diff --git a/src/agentex_sdk/types/state_create_params.py b/src/agentex_sdk/types/state_create_params.py new file mode 100644 index 00000000..b90c8fbb --- /dev/null +++ b/src/agentex_sdk/types/state_create_params.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict +from typing_extensions import Required, TypedDict + +__all__ = ["StateCreateParams"] + + +class StateCreateParams(TypedDict, total=False): + agent_id: Required[str] + + state: Required[Dict[str, object]] + + task_id: Required[str] diff --git a/src/agentex_sdk/types/state_list_params.py b/src/agentex_sdk/types/state_list_params.py new file mode 100644 index 00000000..6034d345 --- /dev/null +++ b/src/agentex_sdk/types/state_list_params.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import TypedDict + +__all__ = ["StateListParams"] + + +class StateListParams(TypedDict, total=False): + agent_id: Optional[str] + """Agent ID""" + + task_id: Optional[str] + """Task ID""" diff --git a/src/agentex_sdk/types/state_list_response.py b/src/agentex_sdk/types/state_list_response.py new file mode 100644 index 00000000..2feefedd --- /dev/null +++ b/src/agentex_sdk/types/state_list_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from .state import State + +__all__ = ["StateListResponse"] + +StateListResponse: TypeAlias = List[State] diff --git a/src/agentex_sdk/types/state_update_params.py b/src/agentex_sdk/types/state_update_params.py new file mode 100644 index 00000000..28691462 --- /dev/null +++ b/src/agentex_sdk/types/state_update_params.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict +from typing_extensions import Required, TypedDict + +__all__ = ["StateUpdateParams"] + + +class StateUpdateParams(TypedDict, total=False): + agent_id: Required[str] + + state: Required[Dict[str, object]] + + task_id: Required[str] diff --git a/src/agentex_sdk/types/streaming_status.py b/src/agentex_sdk/types/streaming_status.py new file mode 100644 index 00000000..196d7881 --- /dev/null +++ b/src/agentex_sdk/types/streaming_status.py @@ -0,0 +1,7 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing_extensions import Literal, TypeAlias + +__all__ = ["StreamingStatus"] + +StreamingStatus: TypeAlias = Literal["IN_PROGRESS", "DONE"] diff --git a/src/agentex_sdk/types/task.py b/src/agentex_sdk/types/task.py new file mode 100644 index 00000000..c3afef3d --- /dev/null +++ b/src/agentex_sdk/types/task.py @@ -0,0 +1,23 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional +from datetime import datetime +from typing_extensions import Literal + +from .._models import BaseModel + +__all__ = ["Task"] + + +class Task(BaseModel): + id: str + + created_at: Optional[datetime] = None + + name: Optional[str] = None + + status: Optional[Literal["CANCELED", "COMPLETED", "FAILED", "RUNNING", "TERMINATED", "TIMED_OUT"]] = None + + status_reason: Optional[str] = None + + updated_at: Optional[datetime] = None diff --git a/src/agentex_sdk/types/task_list_response.py b/src/agentex_sdk/types/task_list_response.py new file mode 100644 index 00000000..c9607e60 --- /dev/null +++ b/src/agentex_sdk/types/task_list_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from .task import Task + +__all__ = ["TaskListResponse"] + +TaskListResponse: TypeAlias = List[Task] diff --git a/src/agentex_sdk/types/task_message.py b/src/agentex_sdk/types/task_message.py new file mode 100644 index 00000000..686ade7d --- /dev/null +++ b/src/agentex_sdk/types/task_message.py @@ -0,0 +1,36 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Union, Optional +from datetime import datetime +from typing_extensions import Annotated, TypeAlias + +from .._utils import PropertyInfo +from .._models import BaseModel +from .data_content import DataContent +from .text_content import TextContent +from .streaming_status import StreamingStatus +from .tool_request_content import ToolRequestContent +from .tool_response_content import ToolResponseContent + +__all__ = ["TaskMessage", "Content"] + +Content: TypeAlias = Annotated[ + Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") +] + + +class TaskMessage(BaseModel): + id: str + """The task message's unique id""" + + content: Content + + created_at: datetime + """The timestamp when the message was created""" + + task_id: str + + streaming_status: Optional[StreamingStatus] = None + + updated_at: Optional[datetime] = None + """The timestamp when the message was last updated""" diff --git a/src/agentex_sdk/types/tasks/__init__.py b/src/agentex_sdk/types/tasks/__init__.py new file mode 100644 index 00000000..f8ee8b14 --- /dev/null +++ b/src/agentex_sdk/types/tasks/__init__.py @@ -0,0 +1,3 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations diff --git a/src/agentex_sdk/types/text_content.py b/src/agentex_sdk/types/text_content.py new file mode 100644 index 00000000..c96c797f --- /dev/null +++ b/src/agentex_sdk/types/text_content.py @@ -0,0 +1,53 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from typing_extensions import Literal + +from .._models import BaseModel +from .message_style import MessageStyle +from .message_author import MessageAuthor + +__all__ = ["TextContent", "Attachment"] + + +class Attachment(BaseModel): + file_id: str + """The unique ID of the attached file""" + + name: str + """The name of the file""" + + size: int + """The size of the file in bytes""" + + type: str + """The MIME type or content type of the file""" + + +class TextContent(BaseModel): + author: MessageAuthor + """ + The role of the messages author, in this case `system`, `user`, `assistant`, or + `tool`. + """ + + content: str + """The contents of the text message.""" + + attachments: Optional[List[Attachment]] = None + """Optional list of file attachments with structured metadata.""" + + format: Optional[Literal["markdown", "plain", "code"]] = None + """The format of the message. + + This is used by the client to determine how to display the message. + """ + + style: Optional[MessageStyle] = None + """The style of the message. + + This is used by the client to determine how to display the message. + """ + + type: Optional[Literal["text"]] = None + """The type of the message, in this case `text`.""" diff --git a/src/agentex_sdk/types/text_content_param.py b/src/agentex_sdk/types/text_content_param.py new file mode 100644 index 00000000..87f357e0 --- /dev/null +++ b/src/agentex_sdk/types/text_content_param.py @@ -0,0 +1,54 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Iterable, Optional +from typing_extensions import Literal, Required, TypedDict + +from .message_style import MessageStyle +from .message_author import MessageAuthor + +__all__ = ["TextContentParam", "Attachment"] + + +class Attachment(TypedDict, total=False): + file_id: Required[str] + """The unique ID of the attached file""" + + name: Required[str] + """The name of the file""" + + size: Required[int] + """The size of the file in bytes""" + + type: Required[str] + """The MIME type or content type of the file""" + + +class TextContentParam(TypedDict, total=False): + author: Required[MessageAuthor] + """ + The role of the messages author, in this case `system`, `user`, `assistant`, or + `tool`. + """ + + content: Required[str] + """The contents of the text message.""" + + attachments: Optional[Iterable[Attachment]] + """Optional list of file attachments with structured metadata.""" + + format: Literal["markdown", "plain", "code"] + """The format of the message. + + This is used by the client to determine how to display the message. + """ + + style: MessageStyle + """The style of the message. + + This is used by the client to determine how to display the message. + """ + + type: Literal["text"] + """The type of the message, in this case `text`.""" diff --git a/src/agentex_sdk/types/tool_request_content.py b/src/agentex_sdk/types/tool_request_content.py new file mode 100644 index 00000000..66128630 --- /dev/null +++ b/src/agentex_sdk/types/tool_request_content.py @@ -0,0 +1,36 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict, Optional +from typing_extensions import Literal + +from .._models import BaseModel +from .message_style import MessageStyle +from .message_author import MessageAuthor + +__all__ = ["ToolRequestContent"] + + +class ToolRequestContent(BaseModel): + arguments: Dict[str, object] + """The arguments to the tool.""" + + author: MessageAuthor + """ + The role of the messages author, in this case `system`, `user`, `assistant`, or + `tool`. + """ + + name: str + """The name of the tool that is being requested.""" + + tool_call_id: str + """The ID of the tool call that is being requested.""" + + style: Optional[MessageStyle] = None + """The style of the message. + + This is used by the client to determine how to display the message. + """ + + type: Optional[Literal["tool_request"]] = None + """The type of the message, in this case `tool_request`.""" diff --git a/src/agentex_sdk/types/tool_request_content_param.py b/src/agentex_sdk/types/tool_request_content_param.py new file mode 100644 index 00000000..dc2fcb48 --- /dev/null +++ b/src/agentex_sdk/types/tool_request_content_param.py @@ -0,0 +1,37 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict +from typing_extensions import Literal, Required, TypedDict + +from .message_style import MessageStyle +from .message_author import MessageAuthor + +__all__ = ["ToolRequestContentParam"] + + +class ToolRequestContentParam(TypedDict, total=False): + arguments: Required[Dict[str, object]] + """The arguments to the tool.""" + + author: Required[MessageAuthor] + """ + The role of the messages author, in this case `system`, `user`, `assistant`, or + `tool`. + """ + + name: Required[str] + """The name of the tool that is being requested.""" + + tool_call_id: Required[str] + """The ID of the tool call that is being requested.""" + + style: MessageStyle + """The style of the message. + + This is used by the client to determine how to display the message. + """ + + type: Literal["tool_request"] + """The type of the message, in this case `tool_request`.""" diff --git a/src/agentex_sdk/types/tool_response_content.py b/src/agentex_sdk/types/tool_response_content.py new file mode 100644 index 00000000..f6ba15b7 --- /dev/null +++ b/src/agentex_sdk/types/tool_response_content.py @@ -0,0 +1,36 @@ +# 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 +from .message_style import MessageStyle +from .message_author import MessageAuthor + +__all__ = ["ToolResponseContent"] + + +class ToolResponseContent(BaseModel): + author: MessageAuthor + """ + The role of the messages author, in this case `system`, `user`, `assistant`, or + `tool`. + """ + + content: object + """The result of the tool.""" + + name: str + """The name of the tool that is being responded to.""" + + tool_call_id: str + """The ID of the tool call that is being responded to.""" + + style: Optional[MessageStyle] = None + """The style of the message. + + This is used by the client to determine how to display the message. + """ + + type: Optional[Literal["tool_response"]] = None + """The type of the message, in this case `tool_response`.""" diff --git a/src/agentex_sdk/types/tool_response_content_param.py b/src/agentex_sdk/types/tool_response_content_param.py new file mode 100644 index 00000000..e0ea7962 --- /dev/null +++ b/src/agentex_sdk/types/tool_response_content_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 + +from .message_style import MessageStyle +from .message_author import MessageAuthor + +__all__ = ["ToolResponseContentParam"] + + +class ToolResponseContentParam(TypedDict, total=False): + author: Required[MessageAuthor] + """ + The role of the messages author, in this case `system`, `user`, `assistant`, or + `tool`. + """ + + content: Required[object] + """The result of the tool.""" + + name: Required[str] + """The name of the tool that is being responded to.""" + + tool_call_id: Required[str] + """The ID of the tool call that is being responded to.""" + + style: MessageStyle + """The style of the message. + + This is used by the client to determine how to display the message. + """ + + type: Literal["tool_response"] + """The type of the message, in this case `tool_response`.""" diff --git a/src/agentex_sdk/types/tracker_list_params.py b/src/agentex_sdk/types/tracker_list_params.py new file mode 100644 index 00000000..47b4da7b --- /dev/null +++ b/src/agentex_sdk/types/tracker_list_params.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import TypedDict + +__all__ = ["TrackerListParams"] + + +class TrackerListParams(TypedDict, total=False): + agent_id: Optional[str] + """Agent ID""" + + task_id: Optional[str] + """Task ID""" diff --git a/src/agentex_sdk/types/tracker_list_response.py b/src/agentex_sdk/types/tracker_list_response.py new file mode 100644 index 00000000..c5205138 --- /dev/null +++ b/src/agentex_sdk/types/tracker_list_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from .agent_task_tracker import AgentTaskTracker + +__all__ = ["TrackerListResponse"] + +TrackerListResponse: TypeAlias = List[AgentTaskTracker] diff --git a/src/agentex_sdk/types/tracker_update_params.py b/src/agentex_sdk/types/tracker_update_params.py new file mode 100644 index 00000000..127dff4d --- /dev/null +++ b/src/agentex_sdk/types/tracker_update_params.py @@ -0,0 +1,19 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import TypedDict + +__all__ = ["TrackerUpdateParams"] + + +class TrackerUpdateParams(TypedDict, total=False): + last_processed_event_id: Optional[str] + """The most recent processed event ID (omit to leave unchanged)""" + + status: Optional[str] + """Processing status""" + + status_reason: Optional[str] + """Optional status reason""" diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 00000000..fd8019a9 --- /dev/null +++ b/tests/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/__init__.py b/tests/api_resources/__init__.py new file mode 100644 index 00000000..fd8019a9 --- /dev/null +++ b/tests/api_resources/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/agents/__init__.py b/tests/api_resources/agents/__init__.py new file mode 100644 index 00000000..fd8019a9 --- /dev/null +++ b/tests/api_resources/agents/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/agents/test_name.py b/tests/api_resources/agents/test_name.py new file mode 100644 index 00000000..c3df381b --- /dev/null +++ b/tests/api_resources/agents/test_name.py @@ -0,0 +1,192 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from tests.utils import assert_matches_type +from agentex_sdk.types import Agent + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestName: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + def test_method_retrieve(self, client: AgentexSDK) -> None: + name = client.agents.name.retrieve( + "agent_name", + ) + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + response = client.agents.name.with_raw_response.retrieve( + "agent_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = response.parse() + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + with client.agents.name.with_streaming_response.retrieve( + "agent_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = response.parse() + assert_matches_type(Agent, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_retrieve(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + client.agents.name.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_delete(self, client: AgentexSDK) -> None: + name = client.agents.name.delete( + "agent_name", + ) + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_delete(self, client: AgentexSDK) -> None: + response = client.agents.name.with_raw_response.delete( + "agent_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = response.parse() + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_delete(self, client: AgentexSDK) -> None: + with client.agents.name.with_streaming_response.delete( + "agent_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = response.parse() + assert_matches_type(Agent, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_delete(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + client.agents.name.with_raw_response.delete( + "", + ) + + +class TestAsyncName: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip() + @parametrize + async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + name = await async_client.agents.name.retrieve( + "agent_name", + ) + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.agents.name.with_raw_response.retrieve( + "agent_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = await response.parse() + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.agents.name.with_streaming_response.retrieve( + "agent_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = await response.parse() + assert_matches_type(Agent, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + await async_client.agents.name.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_delete(self, async_client: AsyncAgentexSDK) -> None: + name = await async_client.agents.name.delete( + "agent_name", + ) + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_delete(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.agents.name.with_raw_response.delete( + "agent_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = await response.parse() + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_delete(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.agents.name.with_streaming_response.delete( + "agent_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = await response.parse() + assert_matches_type(Agent, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + await async_client.agents.name.with_raw_response.delete( + "", + ) diff --git a/tests/api_resources/messages/__init__.py b/tests/api_resources/messages/__init__.py new file mode 100644 index 00000000..fd8019a9 --- /dev/null +++ b/tests/api_resources/messages/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/messages/test_batch.py b/tests/api_resources/messages/test_batch.py new file mode 100644 index 00000000..b999e8e9 --- /dev/null +++ b/tests/api_resources/messages/test_batch.py @@ -0,0 +1,235 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from tests.utils import assert_matches_type +from agentex_sdk.types.messages import ( + BatchCreateResponse, + BatchUpdateResponse, +) + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestBatch: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + def test_method_create(self, client: AgentexSDK) -> None: + batch = client.messages.batch.create( + contents=[ + { + "author": "user", + "content": "content", + } + ], + task_id="task_id", + ) + assert_matches_type(BatchCreateResponse, batch, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_create(self, client: AgentexSDK) -> None: + response = client.messages.batch.with_raw_response.create( + contents=[ + { + "author": "user", + "content": "content", + } + ], + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + batch = response.parse() + assert_matches_type(BatchCreateResponse, batch, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_create(self, client: AgentexSDK) -> None: + with client.messages.batch.with_streaming_response.create( + contents=[ + { + "author": "user", + "content": "content", + } + ], + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + batch = response.parse() + assert_matches_type(BatchCreateResponse, batch, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_method_update(self, client: AgentexSDK) -> None: + batch = client.messages.batch.update( + task_id="task_id", + updates={ + "foo": { + "author": "user", + "content": "content", + } + }, + ) + assert_matches_type(BatchUpdateResponse, batch, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_update(self, client: AgentexSDK) -> None: + response = client.messages.batch.with_raw_response.update( + task_id="task_id", + updates={ + "foo": { + "author": "user", + "content": "content", + } + }, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + batch = response.parse() + assert_matches_type(BatchUpdateResponse, batch, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_update(self, client: AgentexSDK) -> None: + with client.messages.batch.with_streaming_response.update( + task_id="task_id", + updates={ + "foo": { + "author": "user", + "content": "content", + } + }, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + batch = response.parse() + assert_matches_type(BatchUpdateResponse, batch, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncBatch: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip() + @parametrize + async def test_method_create(self, async_client: AsyncAgentexSDK) -> None: + batch = await async_client.messages.batch.create( + contents=[ + { + "author": "user", + "content": "content", + } + ], + task_id="task_id", + ) + assert_matches_type(BatchCreateResponse, batch, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_create(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.messages.batch.with_raw_response.create( + contents=[ + { + "author": "user", + "content": "content", + } + ], + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + batch = await response.parse() + assert_matches_type(BatchCreateResponse, batch, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_create(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.messages.batch.with_streaming_response.create( + contents=[ + { + "author": "user", + "content": "content", + } + ], + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + batch = await response.parse() + assert_matches_type(BatchCreateResponse, batch, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_method_update(self, async_client: AsyncAgentexSDK) -> None: + batch = await async_client.messages.batch.update( + task_id="task_id", + updates={ + "foo": { + "author": "user", + "content": "content", + } + }, + ) + assert_matches_type(BatchUpdateResponse, batch, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_update(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.messages.batch.with_raw_response.update( + task_id="task_id", + updates={ + "foo": { + "author": "user", + "content": "content", + } + }, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + batch = await response.parse() + assert_matches_type(BatchUpdateResponse, batch, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_update(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.messages.batch.with_streaming_response.update( + task_id="task_id", + updates={ + "foo": { + "author": "user", + "content": "content", + } + }, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + batch = await response.parse() + assert_matches_type(BatchUpdateResponse, batch, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/tasks/__init__.py b/tests/api_resources/tasks/__init__.py new file mode 100644 index 00000000..fd8019a9 --- /dev/null +++ b/tests/api_resources/tasks/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/tasks/test_name.py b/tests/api_resources/tasks/test_name.py new file mode 100644 index 00000000..3d467559 --- /dev/null +++ b/tests/api_resources/tasks/test_name.py @@ -0,0 +1,274 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from tests.utils import assert_matches_type +from agentex_sdk.types import Task + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestName: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + def test_method_retrieve(self, client: AgentexSDK) -> None: + name = client.tasks.name.retrieve( + "task_name", + ) + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + response = client.tasks.name.with_raw_response.retrieve( + "task_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = response.parse() + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + with client.tasks.name.with_streaming_response.retrieve( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = response.parse() + assert_matches_type(Task, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_retrieve(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + client.tasks.name.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_delete(self, client: AgentexSDK) -> None: + name = client.tasks.name.delete( + "task_name", + ) + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_delete(self, client: AgentexSDK) -> None: + response = client.tasks.name.with_raw_response.delete( + "task_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = response.parse() + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_delete(self, client: AgentexSDK) -> None: + with client.tasks.name.with_streaming_response.delete( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = response.parse() + assert_matches_type(Task, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_delete(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + client.tasks.name.with_raw_response.delete( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_stream_events(self, client: AgentexSDK) -> None: + name_stream = client.tasks.name.stream_events( + "task_name", + ) + name_stream.response.close() + + @pytest.mark.skip() + @parametrize + def test_raw_response_stream_events(self, client: AgentexSDK) -> None: + response = client.tasks.name.with_raw_response.stream_events( + "task_name", + ) + + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + stream = response.parse() + stream.close() + + @pytest.mark.skip() + @parametrize + def test_streaming_response_stream_events(self, client: AgentexSDK) -> None: + with client.tasks.name.with_streaming_response.stream_events( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + stream = response.parse() + stream.close() + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_stream_events(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + client.tasks.name.with_raw_response.stream_events( + "", + ) + + +class TestAsyncName: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip() + @parametrize + async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + name = await async_client.tasks.name.retrieve( + "task_name", + ) + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.tasks.name.with_raw_response.retrieve( + "task_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = await response.parse() + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.tasks.name.with_streaming_response.retrieve( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = await response.parse() + assert_matches_type(Task, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + await async_client.tasks.name.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_delete(self, async_client: AsyncAgentexSDK) -> None: + name = await async_client.tasks.name.delete( + "task_name", + ) + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_delete(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.tasks.name.with_raw_response.delete( + "task_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = await response.parse() + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_delete(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.tasks.name.with_streaming_response.delete( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = await response.parse() + assert_matches_type(Task, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + await async_client.tasks.name.with_raw_response.delete( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_stream_events(self, async_client: AsyncAgentexSDK) -> None: + name_stream = await async_client.tasks.name.stream_events( + "task_name", + ) + await name_stream.response.aclose() + + @pytest.mark.skip() + @parametrize + async def test_raw_response_stream_events(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.tasks.name.with_raw_response.stream_events( + "task_name", + ) + + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + stream = await response.parse() + await stream.close() + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_stream_events(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.tasks.name.with_streaming_response.stream_events( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + stream = await response.parse() + await stream.close() + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_stream_events(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + await async_client.tasks.name.with_raw_response.stream_events( + "", + ) diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py new file mode 100644 index 00000000..094e6b19 --- /dev/null +++ b/tests/api_resources/test_agents.py @@ -0,0 +1,374 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from tests.utils import assert_matches_type +from agentex_sdk.types import Agent, AgentListResponse + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestAgents: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + def test_method_retrieve(self, client: AgentexSDK) -> None: + agent = client.agents.retrieve( + "agent_id", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + response = client.agents.with_raw_response.retrieve( + "agent_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + with client.agents.with_streaming_response.retrieve( + "agent_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_retrieve(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): + client.agents.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_list(self, client: AgentexSDK) -> None: + agent = client.agents.list() + assert_matches_type(AgentListResponse, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_list_with_all_params(self, client: AgentexSDK) -> None: + agent = client.agents.list( + task_id="task_id", + ) + assert_matches_type(AgentListResponse, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_list(self, client: AgentexSDK) -> None: + response = client.agents.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = response.parse() + assert_matches_type(AgentListResponse, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_list(self, client: AgentexSDK) -> None: + with client.agents.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = response.parse() + assert_matches_type(AgentListResponse, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_method_delete(self, client: AgentexSDK) -> None: + agent = client.agents.delete( + "agent_id", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_delete(self, client: AgentexSDK) -> None: + response = client.agents.with_raw_response.delete( + "agent_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_delete(self, client: AgentexSDK) -> None: + with client.agents.with_streaming_response.delete( + "agent_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_delete(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): + client.agents.with_raw_response.delete( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_register(self, client: AgentexSDK) -> None: + agent = client.agents.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_register_with_all_params(self, client: AgentexSDK) -> None: + agent = client.agents.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + agent_id="agent_id", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_register(self, client: AgentexSDK) -> None: + response = client.agents.with_raw_response.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_register(self, client: AgentexSDK) -> None: + with client.agents.with_streaming_response.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncAgents: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip() + @parametrize + async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.retrieve( + "agent_id", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.agents.with_raw_response.retrieve( + "agent_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = await response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.agents.with_streaming_response.retrieve( + "agent_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = await response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): + await async_client.agents.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.list() + assert_matches_type(AgentListResponse, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.list( + task_id="task_id", + ) + assert_matches_type(AgentListResponse, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.agents.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = await response.parse() + assert_matches_type(AgentListResponse, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.agents.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = await response.parse() + assert_matches_type(AgentListResponse, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_method_delete(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.delete( + "agent_id", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_delete(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.agents.with_raw_response.delete( + "agent_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = await response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_delete(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.agents.with_streaming_response.delete( + "agent_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = await response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): + await async_client.agents.with_raw_response.delete( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_register(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_register_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + agent_id="agent_id", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_register(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.agents.with_raw_response.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = await response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_register(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.agents.with_streaming_response.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = await response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_client.py b/tests/api_resources/test_client.py new file mode 100644 index 00000000..a9616d4a --- /dev/null +++ b/tests/api_resources/test_client.py @@ -0,0 +1,79 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from tests.utils import assert_matches_type + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestClient: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + def test_method_get_root(self, client: AgentexSDK) -> None: + client_ = client.get_root() + assert_matches_type(object, client_, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_get_root(self, client: AgentexSDK) -> None: + response = client.with_raw_response.get_root() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + client_ = response.parse() + assert_matches_type(object, client_, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_get_root(self, client: AgentexSDK) -> None: + with client.with_streaming_response.get_root() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + client_ = response.parse() + assert_matches_type(object, client_, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncClient: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip() + @parametrize + async def test_method_get_root(self, async_client: AsyncAgentexSDK) -> None: + client = await async_client.get_root() + assert_matches_type(object, client, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_get_root(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.with_raw_response.get_root() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + client = await response.parse() + assert_matches_type(object, client, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_get_root(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.with_streaming_response.get_root() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + client = await response.parse() + assert_matches_type(object, client, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_echo.py b/tests/api_resources/test_echo.py new file mode 100644 index 00000000..5b841dc3 --- /dev/null +++ b/tests/api_resources/test_echo.py @@ -0,0 +1,91 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from tests.utils import assert_matches_type + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestEcho: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + def test_method_send(self, client: AgentexSDK) -> None: + echo = client.echo.send( + message="message", + ) + assert_matches_type(object, echo, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_send(self, client: AgentexSDK) -> None: + response = client.echo.with_raw_response.send( + message="message", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + echo = response.parse() + assert_matches_type(object, echo, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_send(self, client: AgentexSDK) -> None: + with client.echo.with_streaming_response.send( + message="message", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + echo = response.parse() + assert_matches_type(object, echo, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncEcho: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip() + @parametrize + async def test_method_send(self, async_client: AsyncAgentexSDK) -> None: + echo = await async_client.echo.send( + message="message", + ) + assert_matches_type(object, echo, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_send(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.echo.with_raw_response.send( + message="message", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + echo = await response.parse() + assert_matches_type(object, echo, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_send(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.echo.with_streaming_response.send( + message="message", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + echo = await response.parse() + assert_matches_type(object, echo, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_events.py b/tests/api_resources/test_events.py new file mode 100644 index 00000000..eced991b --- /dev/null +++ b/tests/api_resources/test_events.py @@ -0,0 +1,204 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from tests.utils import assert_matches_type +from agentex_sdk.types import Event, EventListResponse + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestEvents: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + def test_method_retrieve(self, client: AgentexSDK) -> None: + event = client.events.retrieve( + "event_id", + ) + assert_matches_type(Event, event, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + response = client.events.with_raw_response.retrieve( + "event_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + event = response.parse() + assert_matches_type(Event, event, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + with client.events.with_streaming_response.retrieve( + "event_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + event = response.parse() + assert_matches_type(Event, event, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_retrieve(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `event_id` but received ''"): + client.events.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_list(self, client: AgentexSDK) -> None: + event = client.events.list( + agent_id="agent_id", + task_id="task_id", + ) + assert_matches_type(EventListResponse, event, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_list_with_all_params(self, client: AgentexSDK) -> None: + event = client.events.list( + agent_id="agent_id", + task_id="task_id", + last_processed_event_id="last_processed_event_id", + limit=1, + ) + assert_matches_type(EventListResponse, event, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_list(self, client: AgentexSDK) -> None: + response = client.events.with_raw_response.list( + agent_id="agent_id", + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + event = response.parse() + assert_matches_type(EventListResponse, event, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_list(self, client: AgentexSDK) -> None: + with client.events.with_streaming_response.list( + agent_id="agent_id", + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + event = response.parse() + assert_matches_type(EventListResponse, event, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncEvents: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip() + @parametrize + async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + event = await async_client.events.retrieve( + "event_id", + ) + assert_matches_type(Event, event, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.events.with_raw_response.retrieve( + "event_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + event = await response.parse() + assert_matches_type(Event, event, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.events.with_streaming_response.retrieve( + "event_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + event = await response.parse() + assert_matches_type(Event, event, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `event_id` but received ''"): + await async_client.events.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: + event = await async_client.events.list( + agent_id="agent_id", + task_id="task_id", + ) + assert_matches_type(EventListResponse, event, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + event = await async_client.events.list( + agent_id="agent_id", + task_id="task_id", + last_processed_event_id="last_processed_event_id", + limit=1, + ) + assert_matches_type(EventListResponse, event, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.events.with_raw_response.list( + agent_id="agent_id", + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + event = await response.parse() + assert_matches_type(EventListResponse, event, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.events.with_streaming_response.list( + agent_id="agent_id", + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + event = await response.parse() + assert_matches_type(EventListResponse, event, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py new file mode 100644 index 00000000..2a6a849c --- /dev/null +++ b/tests/api_resources/test_messages.py @@ -0,0 +1,525 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from tests.utils import assert_matches_type +from agentex_sdk.types import ( + TaskMessage, + MessageListResponse, +) + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestMessages: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + def test_method_create(self, client: AgentexSDK) -> None: + message = client.messages.create( + content={ + "author": "user", + "content": "content", + "type": "text", + }, + task_id="task_id", + ) + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_create_with_all_params(self, client: AgentexSDK) -> None: + message = client.messages.create( + content={ + "author": "user", + "content": "content", + "attachments": [ + { + "file_id": "file_id", + "name": "name", + "size": 0, + "type": "type", + } + ], + "format": "markdown", + "style": "static", + "type": "text", + }, + task_id="task_id", + streaming_status="IN_PROGRESS", + ) + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_create(self, client: AgentexSDK) -> None: + response = client.messages.with_raw_response.create( + content={ + "author": "user", + "content": "content", + "type": "text", + }, + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = response.parse() + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_create(self, client: AgentexSDK) -> None: + with client.messages.with_streaming_response.create( + content={ + "author": "user", + "content": "content", + "type": "text", + }, + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = response.parse() + assert_matches_type(TaskMessage, message, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_method_retrieve(self, client: AgentexSDK) -> None: + message = client.messages.retrieve( + "message_id", + ) + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + response = client.messages.with_raw_response.retrieve( + "message_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = response.parse() + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + with client.messages.with_streaming_response.retrieve( + "message_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = response.parse() + assert_matches_type(TaskMessage, message, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_retrieve(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"): + client.messages.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_update(self, client: AgentexSDK) -> None: + message = client.messages.update( + message_id="message_id", + content={ + "author": "user", + "content": "content", + "type": "text", + }, + task_id="task_id", + ) + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_update_with_all_params(self, client: AgentexSDK) -> None: + message = client.messages.update( + message_id="message_id", + content={ + "author": "user", + "content": "content", + "attachments": [ + { + "file_id": "file_id", + "name": "name", + "size": 0, + "type": "type", + } + ], + "format": "markdown", + "style": "static", + "type": "text", + }, + task_id="task_id", + streaming_status="IN_PROGRESS", + ) + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_update(self, client: AgentexSDK) -> None: + response = client.messages.with_raw_response.update( + message_id="message_id", + content={ + "author": "user", + "content": "content", + "type": "text", + }, + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = response.parse() + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_update(self, client: AgentexSDK) -> None: + with client.messages.with_streaming_response.update( + message_id="message_id", + content={ + "author": "user", + "content": "content", + "type": "text", + }, + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = response.parse() + assert_matches_type(TaskMessage, message, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_update(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"): + client.messages.with_raw_response.update( + message_id="", + content={ + "author": "user", + "content": "content", + "type": "text", + }, + task_id="task_id", + ) + + @pytest.mark.skip() + @parametrize + def test_method_list(self, client: AgentexSDK) -> None: + message = client.messages.list( + task_id="task_id", + ) + assert_matches_type(MessageListResponse, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_list_with_all_params(self, client: AgentexSDK) -> None: + message = client.messages.list( + task_id="task_id", + limit=0, + ) + assert_matches_type(MessageListResponse, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_list(self, client: AgentexSDK) -> None: + response = client.messages.with_raw_response.list( + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = response.parse() + assert_matches_type(MessageListResponse, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_list(self, client: AgentexSDK) -> None: + with client.messages.with_streaming_response.list( + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = response.parse() + assert_matches_type(MessageListResponse, message, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncMessages: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip() + @parametrize + async def test_method_create(self, async_client: AsyncAgentexSDK) -> None: + message = await async_client.messages.create( + content={ + "author": "user", + "content": "content", + "type": "text", + }, + task_id="task_id", + ) + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_create_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + message = await async_client.messages.create( + content={ + "author": "user", + "content": "content", + "attachments": [ + { + "file_id": "file_id", + "name": "name", + "size": 0, + "type": "type", + } + ], + "format": "markdown", + "style": "static", + "type": "text", + }, + task_id="task_id", + streaming_status="IN_PROGRESS", + ) + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_create(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.messages.with_raw_response.create( + content={ + "author": "user", + "content": "content", + "type": "text", + }, + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = await response.parse() + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_create(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.messages.with_streaming_response.create( + content={ + "author": "user", + "content": "content", + "type": "text", + }, + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = await response.parse() + assert_matches_type(TaskMessage, message, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + message = await async_client.messages.retrieve( + "message_id", + ) + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.messages.with_raw_response.retrieve( + "message_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = await response.parse() + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.messages.with_streaming_response.retrieve( + "message_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = await response.parse() + assert_matches_type(TaskMessage, message, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"): + await async_client.messages.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_update(self, async_client: AsyncAgentexSDK) -> None: + message = await async_client.messages.update( + message_id="message_id", + content={ + "author": "user", + "content": "content", + "type": "text", + }, + task_id="task_id", + ) + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_update_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + message = await async_client.messages.update( + message_id="message_id", + content={ + "author": "user", + "content": "content", + "attachments": [ + { + "file_id": "file_id", + "name": "name", + "size": 0, + "type": "type", + } + ], + "format": "markdown", + "style": "static", + "type": "text", + }, + task_id="task_id", + streaming_status="IN_PROGRESS", + ) + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_update(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.messages.with_raw_response.update( + message_id="message_id", + content={ + "author": "user", + "content": "content", + "type": "text", + }, + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = await response.parse() + assert_matches_type(TaskMessage, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_update(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.messages.with_streaming_response.update( + message_id="message_id", + content={ + "author": "user", + "content": "content", + "type": "text", + }, + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = await response.parse() + assert_matches_type(TaskMessage, message, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_update(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"): + await async_client.messages.with_raw_response.update( + message_id="", + content={ + "author": "user", + "content": "content", + "type": "text", + }, + task_id="task_id", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: + message = await async_client.messages.list( + task_id="task_id", + ) + assert_matches_type(MessageListResponse, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + message = await async_client.messages.list( + task_id="task_id", + limit=0, + ) + assert_matches_type(MessageListResponse, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.messages.with_raw_response.list( + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = await response.parse() + assert_matches_type(MessageListResponse, message, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.messages.with_streaming_response.list( + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = await response.parse() + assert_matches_type(MessageListResponse, message, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_spans.py b/tests/api_resources/test_spans.py new file mode 100644 index 00000000..7e748ccc --- /dev/null +++ b/tests/api_resources/test_spans.py @@ -0,0 +1,409 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from tests.utils import assert_matches_type +from agentex_sdk.types import Span, SpanListResponse +from agentex_sdk._utils import parse_datetime + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestSpans: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + def test_method_create(self, client: AgentexSDK) -> None: + span = client.spans.create( + name="name", + start_time=parse_datetime("2019-12-27T18:11:19.117Z"), + trace_id="trace_id", + ) + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_create_with_all_params(self, client: AgentexSDK) -> None: + span = client.spans.create( + name="name", + start_time=parse_datetime("2019-12-27T18:11:19.117Z"), + trace_id="trace_id", + id="id", + data={"foo": "bar"}, + end_time=parse_datetime("2019-12-27T18:11:19.117Z"), + input={"foo": "bar"}, + output={"foo": "bar"}, + parent_id="parent_id", + ) + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_create(self, client: AgentexSDK) -> None: + response = client.spans.with_raw_response.create( + name="name", + start_time=parse_datetime("2019-12-27T18:11:19.117Z"), + trace_id="trace_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + span = response.parse() + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_create(self, client: AgentexSDK) -> None: + with client.spans.with_streaming_response.create( + name="name", + start_time=parse_datetime("2019-12-27T18:11:19.117Z"), + trace_id="trace_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + span = response.parse() + assert_matches_type(Span, span, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_method_retrieve(self, client: AgentexSDK) -> None: + span = client.spans.retrieve( + "span_id", + ) + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + response = client.spans.with_raw_response.retrieve( + "span_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + span = response.parse() + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + with client.spans.with_streaming_response.retrieve( + "span_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + span = response.parse() + assert_matches_type(Span, span, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_retrieve(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `span_id` but received ''"): + client.spans.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_update(self, client: AgentexSDK) -> None: + span = client.spans.update( + span_id="span_id", + ) + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_update_with_all_params(self, client: AgentexSDK) -> None: + span = client.spans.update( + span_id="span_id", + data={"foo": "bar"}, + end_time=parse_datetime("2019-12-27T18:11:19.117Z"), + input={"foo": "bar"}, + name="name", + output={"foo": "bar"}, + parent_id="parent_id", + start_time=parse_datetime("2019-12-27T18:11:19.117Z"), + trace_id="trace_id", + ) + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_update(self, client: AgentexSDK) -> None: + response = client.spans.with_raw_response.update( + span_id="span_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + span = response.parse() + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_update(self, client: AgentexSDK) -> None: + with client.spans.with_streaming_response.update( + span_id="span_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + span = response.parse() + assert_matches_type(Span, span, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_update(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `span_id` but received ''"): + client.spans.with_raw_response.update( + span_id="", + ) + + @pytest.mark.skip() + @parametrize + def test_method_list(self, client: AgentexSDK) -> None: + span = client.spans.list() + assert_matches_type(SpanListResponse, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_list_with_all_params(self, client: AgentexSDK) -> None: + span = client.spans.list( + trace_id="trace_id", + ) + assert_matches_type(SpanListResponse, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_list(self, client: AgentexSDK) -> None: + response = client.spans.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + span = response.parse() + assert_matches_type(SpanListResponse, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_list(self, client: AgentexSDK) -> None: + with client.spans.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + span = response.parse() + assert_matches_type(SpanListResponse, span, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncSpans: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip() + @parametrize + async def test_method_create(self, async_client: AsyncAgentexSDK) -> None: + span = await async_client.spans.create( + name="name", + start_time=parse_datetime("2019-12-27T18:11:19.117Z"), + trace_id="trace_id", + ) + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_create_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + span = await async_client.spans.create( + name="name", + start_time=parse_datetime("2019-12-27T18:11:19.117Z"), + trace_id="trace_id", + id="id", + data={"foo": "bar"}, + end_time=parse_datetime("2019-12-27T18:11:19.117Z"), + input={"foo": "bar"}, + output={"foo": "bar"}, + parent_id="parent_id", + ) + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_create(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.spans.with_raw_response.create( + name="name", + start_time=parse_datetime("2019-12-27T18:11:19.117Z"), + trace_id="trace_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + span = await response.parse() + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_create(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.spans.with_streaming_response.create( + name="name", + start_time=parse_datetime("2019-12-27T18:11:19.117Z"), + trace_id="trace_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + span = await response.parse() + assert_matches_type(Span, span, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + span = await async_client.spans.retrieve( + "span_id", + ) + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.spans.with_raw_response.retrieve( + "span_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + span = await response.parse() + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.spans.with_streaming_response.retrieve( + "span_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + span = await response.parse() + assert_matches_type(Span, span, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `span_id` but received ''"): + await async_client.spans.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_update(self, async_client: AsyncAgentexSDK) -> None: + span = await async_client.spans.update( + span_id="span_id", + ) + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_update_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + span = await async_client.spans.update( + span_id="span_id", + data={"foo": "bar"}, + end_time=parse_datetime("2019-12-27T18:11:19.117Z"), + input={"foo": "bar"}, + name="name", + output={"foo": "bar"}, + parent_id="parent_id", + start_time=parse_datetime("2019-12-27T18:11:19.117Z"), + trace_id="trace_id", + ) + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_update(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.spans.with_raw_response.update( + span_id="span_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + span = await response.parse() + assert_matches_type(Span, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_update(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.spans.with_streaming_response.update( + span_id="span_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + span = await response.parse() + assert_matches_type(Span, span, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_update(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `span_id` but received ''"): + await async_client.spans.with_raw_response.update( + span_id="", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: + span = await async_client.spans.list() + assert_matches_type(SpanListResponse, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + span = await async_client.spans.list( + trace_id="trace_id", + ) + assert_matches_type(SpanListResponse, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.spans.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + span = await response.parse() + assert_matches_type(SpanListResponse, span, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.spans.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + span = await response.parse() + assert_matches_type(SpanListResponse, span, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_states.py b/tests/api_resources/test_states.py new file mode 100644 index 00000000..83e09dfd --- /dev/null +++ b/tests/api_resources/test_states.py @@ -0,0 +1,454 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from tests.utils import assert_matches_type +from agentex_sdk.types import State, StateListResponse + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestStates: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + def test_method_create(self, client: AgentexSDK) -> None: + state = client.states.create( + agent_id="agent_id", + state={"foo": "bar"}, + task_id="task_id", + ) + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_create(self, client: AgentexSDK) -> None: + response = client.states.with_raw_response.create( + agent_id="agent_id", + state={"foo": "bar"}, + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + state = response.parse() + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_create(self, client: AgentexSDK) -> None: + with client.states.with_streaming_response.create( + agent_id="agent_id", + state={"foo": "bar"}, + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + state = response.parse() + assert_matches_type(State, state, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_method_retrieve(self, client: AgentexSDK) -> None: + state = client.states.retrieve( + "state_id", + ) + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + response = client.states.with_raw_response.retrieve( + "state_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + state = response.parse() + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + with client.states.with_streaming_response.retrieve( + "state_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + state = response.parse() + assert_matches_type(State, state, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_retrieve(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): + client.states.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_update(self, client: AgentexSDK) -> None: + state = client.states.update( + state_id="state_id", + agent_id="agent_id", + state={"foo": "bar"}, + task_id="task_id", + ) + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_update(self, client: AgentexSDK) -> None: + response = client.states.with_raw_response.update( + state_id="state_id", + agent_id="agent_id", + state={"foo": "bar"}, + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + state = response.parse() + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_update(self, client: AgentexSDK) -> None: + with client.states.with_streaming_response.update( + state_id="state_id", + agent_id="agent_id", + state={"foo": "bar"}, + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + state = response.parse() + assert_matches_type(State, state, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_update(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): + client.states.with_raw_response.update( + state_id="", + agent_id="agent_id", + state={"foo": "bar"}, + task_id="task_id", + ) + + @pytest.mark.skip() + @parametrize + def test_method_list(self, client: AgentexSDK) -> None: + state = client.states.list() + assert_matches_type(StateListResponse, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_list_with_all_params(self, client: AgentexSDK) -> None: + state = client.states.list( + agent_id="agent_id", + task_id="task_id", + ) + assert_matches_type(StateListResponse, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_list(self, client: AgentexSDK) -> None: + response = client.states.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + state = response.parse() + assert_matches_type(StateListResponse, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_list(self, client: AgentexSDK) -> None: + with client.states.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + state = response.parse() + assert_matches_type(StateListResponse, state, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_method_delete(self, client: AgentexSDK) -> None: + state = client.states.delete( + "state_id", + ) + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_delete(self, client: AgentexSDK) -> None: + response = client.states.with_raw_response.delete( + "state_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + state = response.parse() + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_delete(self, client: AgentexSDK) -> None: + with client.states.with_streaming_response.delete( + "state_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + state = response.parse() + assert_matches_type(State, state, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_delete(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): + client.states.with_raw_response.delete( + "", + ) + + +class TestAsyncStates: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip() + @parametrize + async def test_method_create(self, async_client: AsyncAgentexSDK) -> None: + state = await async_client.states.create( + agent_id="agent_id", + state={"foo": "bar"}, + task_id="task_id", + ) + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_create(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.states.with_raw_response.create( + agent_id="agent_id", + state={"foo": "bar"}, + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + state = await response.parse() + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_create(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.states.with_streaming_response.create( + agent_id="agent_id", + state={"foo": "bar"}, + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + state = await response.parse() + assert_matches_type(State, state, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + state = await async_client.states.retrieve( + "state_id", + ) + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.states.with_raw_response.retrieve( + "state_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + state = await response.parse() + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.states.with_streaming_response.retrieve( + "state_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + state = await response.parse() + assert_matches_type(State, state, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): + await async_client.states.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_update(self, async_client: AsyncAgentexSDK) -> None: + state = await async_client.states.update( + state_id="state_id", + agent_id="agent_id", + state={"foo": "bar"}, + task_id="task_id", + ) + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_update(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.states.with_raw_response.update( + state_id="state_id", + agent_id="agent_id", + state={"foo": "bar"}, + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + state = await response.parse() + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_update(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.states.with_streaming_response.update( + state_id="state_id", + agent_id="agent_id", + state={"foo": "bar"}, + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + state = await response.parse() + assert_matches_type(State, state, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_update(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): + await async_client.states.with_raw_response.update( + state_id="", + agent_id="agent_id", + state={"foo": "bar"}, + task_id="task_id", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: + state = await async_client.states.list() + assert_matches_type(StateListResponse, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + state = await async_client.states.list( + agent_id="agent_id", + task_id="task_id", + ) + assert_matches_type(StateListResponse, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.states.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + state = await response.parse() + assert_matches_type(StateListResponse, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.states.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + state = await response.parse() + assert_matches_type(StateListResponse, state, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_method_delete(self, async_client: AsyncAgentexSDK) -> None: + state = await async_client.states.delete( + "state_id", + ) + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_delete(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.states.with_raw_response.delete( + "state_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + state = await response.parse() + assert_matches_type(State, state, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_delete(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.states.with_streaming_response.delete( + "state_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + state = await response.parse() + assert_matches_type(State, state, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): + await async_client.states.with_raw_response.delete( + "", + ) diff --git a/tests/api_resources/test_tasks.py b/tests/api_resources/test_tasks.py new file mode 100644 index 00000000..4d84c07e --- /dev/null +++ b/tests/api_resources/test_tasks.py @@ -0,0 +1,330 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from tests.utils import assert_matches_type +from agentex_sdk.types import Task, TaskListResponse + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestTasks: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + def test_method_retrieve(self, client: AgentexSDK) -> None: + task = client.tasks.retrieve( + "task_id", + ) + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + response = client.tasks.with_raw_response.retrieve( + "task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + task = response.parse() + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + with client.tasks.with_streaming_response.retrieve( + "task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + task = response.parse() + assert_matches_type(Task, task, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_retrieve(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): + client.tasks.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_list(self, client: AgentexSDK) -> None: + task = client.tasks.list() + assert_matches_type(TaskListResponse, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_list(self, client: AgentexSDK) -> None: + response = client.tasks.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + task = response.parse() + assert_matches_type(TaskListResponse, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_list(self, client: AgentexSDK) -> None: + with client.tasks.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + task = response.parse() + assert_matches_type(TaskListResponse, task, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_method_delete(self, client: AgentexSDK) -> None: + task = client.tasks.delete( + "task_id", + ) + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_delete(self, client: AgentexSDK) -> None: + response = client.tasks.with_raw_response.delete( + "task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + task = response.parse() + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_delete(self, client: AgentexSDK) -> None: + with client.tasks.with_streaming_response.delete( + "task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + task = response.parse() + assert_matches_type(Task, task, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_delete(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): + client.tasks.with_raw_response.delete( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_stream_events(self, client: AgentexSDK) -> None: + task_stream = client.tasks.stream_events( + "task_id", + ) + task_stream.response.close() + + @pytest.mark.skip() + @parametrize + def test_raw_response_stream_events(self, client: AgentexSDK) -> None: + response = client.tasks.with_raw_response.stream_events( + "task_id", + ) + + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + stream = response.parse() + stream.close() + + @pytest.mark.skip() + @parametrize + def test_streaming_response_stream_events(self, client: AgentexSDK) -> None: + with client.tasks.with_streaming_response.stream_events( + "task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + stream = response.parse() + stream.close() + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_stream_events(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): + client.tasks.with_raw_response.stream_events( + "", + ) + + +class TestAsyncTasks: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip() + @parametrize + async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + task = await async_client.tasks.retrieve( + "task_id", + ) + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.tasks.with_raw_response.retrieve( + "task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + task = await response.parse() + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.tasks.with_streaming_response.retrieve( + "task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + task = await response.parse() + assert_matches_type(Task, task, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): + await async_client.tasks.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: + task = await async_client.tasks.list() + assert_matches_type(TaskListResponse, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.tasks.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + task = await response.parse() + assert_matches_type(TaskListResponse, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.tasks.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + task = await response.parse() + assert_matches_type(TaskListResponse, task, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_method_delete(self, async_client: AsyncAgentexSDK) -> None: + task = await async_client.tasks.delete( + "task_id", + ) + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_delete(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.tasks.with_raw_response.delete( + "task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + task = await response.parse() + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_delete(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.tasks.with_streaming_response.delete( + "task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + task = await response.parse() + assert_matches_type(Task, task, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): + await async_client.tasks.with_raw_response.delete( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_stream_events(self, async_client: AsyncAgentexSDK) -> None: + task_stream = await async_client.tasks.stream_events( + "task_id", + ) + await task_stream.response.aclose() + + @pytest.mark.skip() + @parametrize + async def test_raw_response_stream_events(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.tasks.with_raw_response.stream_events( + "task_id", + ) + + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + stream = await response.parse() + await stream.close() + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_stream_events(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.tasks.with_streaming_response.stream_events( + "task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + stream = await response.parse() + await stream.close() + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_stream_events(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): + await async_client.tasks.with_raw_response.stream_events( + "", + ) diff --git a/tests/api_resources/test_tracker.py b/tests/api_resources/test_tracker.py new file mode 100644 index 00000000..8c8ffba5 --- /dev/null +++ b/tests/api_resources/test_tracker.py @@ -0,0 +1,288 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from tests.utils import assert_matches_type +from agentex_sdk.types import AgentTaskTracker, TrackerListResponse + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestTracker: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + def test_method_retrieve(self, client: AgentexSDK) -> None: + tracker = client.tracker.retrieve( + "tracker_id", + ) + assert_matches_type(AgentTaskTracker, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + response = client.tracker.with_raw_response.retrieve( + "tracker_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + tracker = response.parse() + assert_matches_type(AgentTaskTracker, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + with client.tracker.with_streaming_response.retrieve( + "tracker_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + tracker = response.parse() + assert_matches_type(AgentTaskTracker, tracker, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_retrieve(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `tracker_id` but received ''"): + client.tracker.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_update(self, client: AgentexSDK) -> None: + tracker = client.tracker.update( + tracker_id="tracker_id", + ) + assert_matches_type(AgentTaskTracker, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_update_with_all_params(self, client: AgentexSDK) -> None: + tracker = client.tracker.update( + tracker_id="tracker_id", + last_processed_event_id="last_processed_event_id", + status="status", + status_reason="status_reason", + ) + assert_matches_type(AgentTaskTracker, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_update(self, client: AgentexSDK) -> None: + response = client.tracker.with_raw_response.update( + tracker_id="tracker_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + tracker = response.parse() + assert_matches_type(AgentTaskTracker, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_update(self, client: AgentexSDK) -> None: + with client.tracker.with_streaming_response.update( + tracker_id="tracker_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + tracker = response.parse() + assert_matches_type(AgentTaskTracker, tracker, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_update(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `tracker_id` but received ''"): + client.tracker.with_raw_response.update( + tracker_id="", + ) + + @pytest.mark.skip() + @parametrize + def test_method_list(self, client: AgentexSDK) -> None: + tracker = client.tracker.list() + assert_matches_type(TrackerListResponse, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_list_with_all_params(self, client: AgentexSDK) -> None: + tracker = client.tracker.list( + agent_id="agent_id", + task_id="task_id", + ) + assert_matches_type(TrackerListResponse, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_list(self, client: AgentexSDK) -> None: + response = client.tracker.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + tracker = response.parse() + assert_matches_type(TrackerListResponse, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_list(self, client: AgentexSDK) -> None: + with client.tracker.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + tracker = response.parse() + assert_matches_type(TrackerListResponse, tracker, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncTracker: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip() + @parametrize + async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + tracker = await async_client.tracker.retrieve( + "tracker_id", + ) + assert_matches_type(AgentTaskTracker, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.tracker.with_raw_response.retrieve( + "tracker_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + tracker = await response.parse() + assert_matches_type(AgentTaskTracker, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.tracker.with_streaming_response.retrieve( + "tracker_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + tracker = await response.parse() + assert_matches_type(AgentTaskTracker, tracker, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `tracker_id` but received ''"): + await async_client.tracker.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_update(self, async_client: AsyncAgentexSDK) -> None: + tracker = await async_client.tracker.update( + tracker_id="tracker_id", + ) + assert_matches_type(AgentTaskTracker, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_update_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + tracker = await async_client.tracker.update( + tracker_id="tracker_id", + last_processed_event_id="last_processed_event_id", + status="status", + status_reason="status_reason", + ) + assert_matches_type(AgentTaskTracker, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_update(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.tracker.with_raw_response.update( + tracker_id="tracker_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + tracker = await response.parse() + assert_matches_type(AgentTaskTracker, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_update(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.tracker.with_streaming_response.update( + tracker_id="tracker_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + tracker = await response.parse() + assert_matches_type(AgentTaskTracker, tracker, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_update(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `tracker_id` but received ''"): + await async_client.tracker.with_raw_response.update( + tracker_id="", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: + tracker = await async_client.tracker.list() + assert_matches_type(TrackerListResponse, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + tracker = await async_client.tracker.list( + agent_id="agent_id", + task_id="task_id", + ) + assert_matches_type(TrackerListResponse, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.tracker.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + tracker = await response.parse() + assert_matches_type(TrackerListResponse, tracker, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.tracker.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + tracker = await response.parse() + assert_matches_type(TrackerListResponse, tracker, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 00000000..c65ffa83 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,84 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +import logging +from typing import TYPE_CHECKING, Iterator, AsyncIterator + +import httpx +import pytest +from pytest_asyncio import is_async_test + +from agentex_sdk import AgentexSDK, AsyncAgentexSDK, DefaultAioHttpClient +from agentex_sdk._utils import is_dict + +if TYPE_CHECKING: + from _pytest.fixtures import FixtureRequest # pyright: ignore[reportPrivateImportUsage] + +pytest.register_assert_rewrite("tests.utils") + +logging.getLogger("agentex_sdk").setLevel(logging.DEBUG) + + +# automatically add `pytest.mark.asyncio()` to all of our async tests +# so we don't have to add that boilerplate everywhere +def pytest_collection_modifyitems(items: list[pytest.Function]) -> None: + pytest_asyncio_tests = (item for item in items if is_async_test(item)) + session_scope_marker = pytest.mark.asyncio(loop_scope="session") + for async_test in pytest_asyncio_tests: + async_test.add_marker(session_scope_marker, append=False) + + # We skip tests that use both the aiohttp client and respx_mock as respx_mock + # doesn't support custom transports. + for item in items: + if "async_client" not in item.fixturenames or "respx_mock" not in item.fixturenames: + continue + + if not hasattr(item, "callspec"): + continue + + async_client_param = item.callspec.params.get("async_client") + if is_dict(async_client_param) and async_client_param.get("http_client") == "aiohttp": + item.add_marker(pytest.mark.skip(reason="aiohttp client is not compatible with respx_mock")) + + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + +api_key = "My API Key" + + +@pytest.fixture(scope="session") +def client(request: FixtureRequest) -> Iterator[AgentexSDK]: + strict = getattr(request, "param", True) + if not isinstance(strict, bool): + raise TypeError(f"Unexpected fixture parameter type {type(strict)}, expected {bool}") + + with AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=strict) as client: + yield client + + +@pytest.fixture(scope="session") +async def async_client(request: FixtureRequest) -> AsyncIterator[AsyncAgentexSDK]: + param = getattr(request, "param", True) + + # defaults + strict = True + http_client: None | httpx.AsyncClient = None + + if isinstance(param, bool): + strict = param + elif is_dict(param): + strict = param.get("strict", True) + assert isinstance(strict, bool) + + http_client_type = param.get("http_client", "httpx") + if http_client_type == "aiohttp": + http_client = DefaultAioHttpClient() + else: + raise TypeError(f"Unexpected fixture parameter type {type(param)}, expected bool or dict") + + async with AsyncAgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=strict, http_client=http_client + ) as client: + yield client diff --git a/tests/sample_file.txt b/tests/sample_file.txt new file mode 100644 index 00000000..af5626b4 --- /dev/null +++ b/tests/sample_file.txt @@ -0,0 +1 @@ +Hello, world! diff --git a/tests/test_client.py b/tests/test_client.py new file mode 100644 index 00000000..26e8f818 --- /dev/null +++ b/tests/test_client.py @@ -0,0 +1,1758 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import gc +import os +import sys +import json +import time +import asyncio +import inspect +import subprocess +import tracemalloc +from typing import Any, Union, cast +from textwrap import dedent +from unittest import mock +from typing_extensions import Literal + +import httpx +import pytest +from respx import MockRouter +from pydantic import ValidationError + +from agentex_sdk import AgentexSDK, AsyncAgentexSDK, APIResponseValidationError +from agentex_sdk._types import Omit +from agentex_sdk._models import BaseModel, FinalRequestOptions +from agentex_sdk._exceptions import APIStatusError, APITimeoutError, APIResponseValidationError +from agentex_sdk._base_client import ( + DEFAULT_TIMEOUT, + HTTPX_DEFAULT_TIMEOUT, + BaseClient, + DefaultHttpxClient, + DefaultAsyncHttpxClient, + make_request_options, +) + +from .utils import update_env + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") +api_key = "My API Key" + + +def _get_params(client: BaseClient[Any, Any]) -> dict[str, str]: + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + url = httpx.URL(request.url) + return dict(url.params) + + +def _low_retry_timeout(*_args: Any, **_kwargs: Any) -> float: + return 0.1 + + +def _get_open_connections(client: AgentexSDK | AsyncAgentexSDK) -> int: + transport = client._client._transport + assert isinstance(transport, httpx.HTTPTransport) or isinstance(transport, httpx.AsyncHTTPTransport) + + pool = transport._pool + return len(pool._requests) + + +class TestAgentexSDK: + client = AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + + @pytest.mark.respx(base_url=base_url) + def test_raw_response(self, respx_mock: MockRouter) -> None: + respx_mock.post("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"})) + + response = self.client.post("/foo", cast_to=httpx.Response) + assert response.status_code == 200 + assert isinstance(response, httpx.Response) + assert response.json() == {"foo": "bar"} + + @pytest.mark.respx(base_url=base_url) + def test_raw_response_for_binary(self, respx_mock: MockRouter) -> None: + respx_mock.post("/foo").mock( + return_value=httpx.Response(200, headers={"Content-Type": "application/binary"}, content='{"foo": "bar"}') + ) + + response = self.client.post("/foo", cast_to=httpx.Response) + assert response.status_code == 200 + assert isinstance(response, httpx.Response) + assert response.json() == {"foo": "bar"} + + def test_copy(self) -> None: + copied = self.client.copy() + assert id(copied) != id(self.client) + + copied = self.client.copy(api_key="another My API Key") + assert copied.api_key == "another My API Key" + assert self.client.api_key == "My API Key" + + def test_copy_default_options(self) -> None: + # options that have a default are overridden correctly + copied = self.client.copy(max_retries=7) + assert copied.max_retries == 7 + assert self.client.max_retries == 2 + + copied2 = copied.copy(max_retries=6) + assert copied2.max_retries == 6 + assert copied.max_retries == 7 + + # timeout + assert isinstance(self.client.timeout, httpx.Timeout) + copied = self.client.copy(timeout=None) + assert copied.timeout is None + assert isinstance(self.client.timeout, httpx.Timeout) + + def test_copy_default_headers(self) -> None: + client = AgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} + ) + assert client.default_headers["X-Foo"] == "bar" + + # does not override the already given value when not specified + copied = client.copy() + assert copied.default_headers["X-Foo"] == "bar" + + # merges already given headers + copied = client.copy(default_headers={"X-Bar": "stainless"}) + assert copied.default_headers["X-Foo"] == "bar" + assert copied.default_headers["X-Bar"] == "stainless" + + # uses new values for any already given headers + copied = client.copy(default_headers={"X-Foo": "stainless"}) + assert copied.default_headers["X-Foo"] == "stainless" + + # set_default_headers + + # completely overrides already set values + copied = client.copy(set_default_headers={}) + assert copied.default_headers.get("X-Foo") is None + + copied = client.copy(set_default_headers={"X-Bar": "Robert"}) + assert copied.default_headers["X-Bar"] == "Robert" + + with pytest.raises( + ValueError, + match="`default_headers` and `set_default_headers` arguments are mutually exclusive", + ): + client.copy(set_default_headers={}, default_headers={"X-Foo": "Bar"}) + + def test_copy_default_query(self) -> None: + client = AgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"foo": "bar"} + ) + assert _get_params(client)["foo"] == "bar" + + # does not override the already given value when not specified + copied = client.copy() + assert _get_params(copied)["foo"] == "bar" + + # merges already given params + copied = client.copy(default_query={"bar": "stainless"}) + params = _get_params(copied) + assert params["foo"] == "bar" + assert params["bar"] == "stainless" + + # uses new values for any already given headers + copied = client.copy(default_query={"foo": "stainless"}) + assert _get_params(copied)["foo"] == "stainless" + + # set_default_query + + # completely overrides already set values + copied = client.copy(set_default_query={}) + assert _get_params(copied) == {} + + copied = client.copy(set_default_query={"bar": "Robert"}) + assert _get_params(copied)["bar"] == "Robert" + + with pytest.raises( + ValueError, + # TODO: update + match="`default_query` and `set_default_query` arguments are mutually exclusive", + ): + client.copy(set_default_query={}, default_query={"foo": "Bar"}) + + def test_copy_signature(self) -> None: + # ensure the same parameters that can be passed to the client are defined in the `.copy()` method + init_signature = inspect.signature( + # mypy doesn't like that we access the `__init__` property. + self.client.__init__, # type: ignore[misc] + ) + copy_signature = inspect.signature(self.client.copy) + exclude_params = {"transport", "proxies", "_strict_response_validation"} + + for name in init_signature.parameters.keys(): + if name in exclude_params: + continue + + copy_param = copy_signature.parameters.get(name) + assert copy_param is not None, f"copy() signature is missing the {name} param" + + @pytest.mark.skipif(sys.version_info >= (3, 10), reason="fails because of a memory leak that started from 3.12") + def test_copy_build_request(self) -> None: + options = FinalRequestOptions(method="get", url="/foo") + + def build_request(options: FinalRequestOptions) -> None: + client = self.client.copy() + client._build_request(options) + + # ensure that the machinery is warmed up before tracing starts. + build_request(options) + gc.collect() + + tracemalloc.start(1000) + + snapshot_before = tracemalloc.take_snapshot() + + ITERATIONS = 10 + for _ in range(ITERATIONS): + build_request(options) + + gc.collect() + snapshot_after = tracemalloc.take_snapshot() + + tracemalloc.stop() + + def add_leak(leaks: list[tracemalloc.StatisticDiff], diff: tracemalloc.StatisticDiff) -> None: + if diff.count == 0: + # Avoid false positives by considering only leaks (i.e. allocations that persist). + return + + if diff.count % ITERATIONS != 0: + # Avoid false positives by considering only leaks that appear per iteration. + return + + for frame in diff.traceback: + if any( + frame.filename.endswith(fragment) + for fragment in [ + # to_raw_response_wrapper leaks through the @functools.wraps() decorator. + # + # removing the decorator fixes the leak for reasons we don't understand. + "agentex_sdk/_legacy_response.py", + "agentex_sdk/_response.py", + # pydantic.BaseModel.model_dump || pydantic.BaseModel.dict leak memory for some reason. + "agentex_sdk/_compat.py", + # Standard library leaks we don't care about. + "/logging/__init__.py", + ] + ): + return + + leaks.append(diff) + + leaks: list[tracemalloc.StatisticDiff] = [] + for diff in snapshot_after.compare_to(snapshot_before, "traceback"): + add_leak(leaks, diff) + if leaks: + for leak in leaks: + print("MEMORY LEAK:", leak) + for frame in leak.traceback: + print(frame) + raise AssertionError() + + def test_request_timeout(self) -> None: + request = self.client._build_request(FinalRequestOptions(method="get", url="/foo")) + timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore + assert timeout == DEFAULT_TIMEOUT + + request = self.client._build_request( + FinalRequestOptions(method="get", url="/foo", timeout=httpx.Timeout(100.0)) + ) + timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore + assert timeout == httpx.Timeout(100.0) + + def test_client_timeout_option(self) -> None: + client = AgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, timeout=httpx.Timeout(0) + ) + + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore + assert timeout == httpx.Timeout(0) + + def test_http_client_timeout_option(self) -> None: + # custom timeout given to the httpx client should be used + with httpx.Client(timeout=None) as http_client: + client = AgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client + ) + + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore + assert timeout == httpx.Timeout(None) + + # no timeout given to the httpx client should not use the httpx default + with httpx.Client() as http_client: + client = AgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client + ) + + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore + assert timeout == DEFAULT_TIMEOUT + + # explicitly passing the default timeout currently results in it being ignored + with httpx.Client(timeout=HTTPX_DEFAULT_TIMEOUT) as http_client: + client = AgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client + ) + + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore + assert timeout == DEFAULT_TIMEOUT # our default + + async def test_invalid_http_client(self) -> None: + with pytest.raises(TypeError, match="Invalid `http_client` arg"): + async with httpx.AsyncClient() as http_client: + AgentexSDK( + base_url=base_url, + api_key=api_key, + _strict_response_validation=True, + http_client=cast(Any, http_client), + ) + + def test_default_headers_option(self) -> None: + client = AgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} + ) + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + assert request.headers.get("x-foo") == "bar" + assert request.headers.get("x-stainless-lang") == "python" + + client2 = AgentexSDK( + base_url=base_url, + api_key=api_key, + _strict_response_validation=True, + default_headers={ + "X-Foo": "stainless", + "X-Stainless-Lang": "my-overriding-header", + }, + ) + request = client2._build_request(FinalRequestOptions(method="get", url="/foo")) + assert request.headers.get("x-foo") == "stainless" + assert request.headers.get("x-stainless-lang") == "my-overriding-header" + + def test_validate_headers(self) -> None: + client = AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + assert request.headers.get("Authorization") == f"Bearer {api_key}" + + with update_env(**{"AGENTEX_SDK_API_KEY": Omit()}): + client2 = AgentexSDK(base_url=base_url, api_key=None, _strict_response_validation=True) + + with pytest.raises( + TypeError, + match="Could not resolve authentication method. Expected the api_key to be set. Or for the `Authorization` headers to be explicitly omitted", + ): + client2._build_request(FinalRequestOptions(method="get", url="/foo")) + + request2 = client2._build_request( + FinalRequestOptions(method="get", url="/foo", headers={"Authorization": Omit()}) + ) + assert request2.headers.get("Authorization") is None + + def test_default_query_option(self) -> None: + client = AgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"query_param": "bar"} + ) + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + url = httpx.URL(request.url) + assert dict(url.params) == {"query_param": "bar"} + + request = client._build_request( + FinalRequestOptions( + method="get", + url="/foo", + params={"foo": "baz", "query_param": "overridden"}, + ) + ) + url = httpx.URL(request.url) + assert dict(url.params) == {"foo": "baz", "query_param": "overridden"} + + def test_request_extra_json(self) -> None: + request = self.client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + json_data={"foo": "bar"}, + extra_json={"baz": False}, + ), + ) + data = json.loads(request.content.decode("utf-8")) + assert data == {"foo": "bar", "baz": False} + + request = self.client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + extra_json={"baz": False}, + ), + ) + data = json.loads(request.content.decode("utf-8")) + assert data == {"baz": False} + + # `extra_json` takes priority over `json_data` when keys clash + request = self.client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + json_data={"foo": "bar", "baz": True}, + extra_json={"baz": None}, + ), + ) + data = json.loads(request.content.decode("utf-8")) + assert data == {"foo": "bar", "baz": None} + + def test_request_extra_headers(self) -> None: + request = self.client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + **make_request_options(extra_headers={"X-Foo": "Foo"}), + ), + ) + assert request.headers.get("X-Foo") == "Foo" + + # `extra_headers` takes priority over `default_headers` when keys clash + request = self.client.with_options(default_headers={"X-Bar": "true"})._build_request( + FinalRequestOptions( + method="post", + url="/foo", + **make_request_options( + extra_headers={"X-Bar": "false"}, + ), + ), + ) + assert request.headers.get("X-Bar") == "false" + + def test_request_extra_query(self) -> None: + request = self.client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + **make_request_options( + extra_query={"my_query_param": "Foo"}, + ), + ), + ) + params = dict(request.url.params) + assert params == {"my_query_param": "Foo"} + + # if both `query` and `extra_query` are given, they are merged + request = self.client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + **make_request_options( + query={"bar": "1"}, + extra_query={"foo": "2"}, + ), + ), + ) + params = dict(request.url.params) + assert params == {"bar": "1", "foo": "2"} + + # `extra_query` takes priority over `query` when keys clash + request = self.client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + **make_request_options( + query={"foo": "1"}, + extra_query={"foo": "2"}, + ), + ), + ) + params = dict(request.url.params) + assert params == {"foo": "2"} + + def test_multipart_repeating_array(self, client: AgentexSDK) -> None: + request = client._build_request( + FinalRequestOptions.construct( + method="post", + url="/foo", + headers={"Content-Type": "multipart/form-data; boundary=6b7ba517decee4a450543ea6ae821c82"}, + json_data={"array": ["foo", "bar"]}, + files=[("foo.txt", b"hello world")], + ) + ) + + assert request.read().split(b"\r\n") == [ + b"--6b7ba517decee4a450543ea6ae821c82", + b'Content-Disposition: form-data; name="array[]"', + b"", + b"foo", + b"--6b7ba517decee4a450543ea6ae821c82", + b'Content-Disposition: form-data; name="array[]"', + b"", + b"bar", + b"--6b7ba517decee4a450543ea6ae821c82", + b'Content-Disposition: form-data; name="foo.txt"; filename="upload"', + b"Content-Type: application/octet-stream", + b"", + b"hello world", + b"--6b7ba517decee4a450543ea6ae821c82--", + b"", + ] + + @pytest.mark.respx(base_url=base_url) + def test_basic_union_response(self, respx_mock: MockRouter) -> None: + class Model1(BaseModel): + name: str + + class Model2(BaseModel): + foo: str + + respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"})) + + response = self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) + assert isinstance(response, Model2) + assert response.foo == "bar" + + @pytest.mark.respx(base_url=base_url) + def test_union_response_different_types(self, respx_mock: MockRouter) -> None: + """Union of objects with the same field name using a different type""" + + class Model1(BaseModel): + foo: int + + class Model2(BaseModel): + foo: str + + respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"})) + + response = self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) + assert isinstance(response, Model2) + assert response.foo == "bar" + + respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": 1})) + + response = self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) + assert isinstance(response, Model1) + assert response.foo == 1 + + @pytest.mark.respx(base_url=base_url) + def test_non_application_json_content_type_for_json_data(self, respx_mock: MockRouter) -> None: + """ + Response that sets Content-Type to something other than application/json but returns json data + """ + + class Model(BaseModel): + foo: int + + respx_mock.get("/foo").mock( + return_value=httpx.Response( + 200, + content=json.dumps({"foo": 2}), + headers={"Content-Type": "application/text"}, + ) + ) + + response = self.client.get("/foo", cast_to=Model) + assert isinstance(response, Model) + assert response.foo == 2 + + def test_base_url_setter(self) -> None: + client = AgentexSDK(base_url="https://example.com/from_init", api_key=api_key, _strict_response_validation=True) + assert client.base_url == "https://example.com/from_init/" + + client.base_url = "https://example.com/from_setter" # type: ignore[assignment] + + assert client.base_url == "https://example.com/from_setter/" + + def test_base_url_env(self) -> None: + with update_env(AGENTEX_SDK_BASE_URL="http://localhost:5000/from/env"): + client = AgentexSDK(api_key=api_key, _strict_response_validation=True) + assert client.base_url == "http://localhost:5000/from/env/" + + @pytest.mark.parametrize( + "client", + [ + AgentexSDK( + base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True + ), + AgentexSDK( + base_url="http://localhost:5000/custom/path/", + api_key=api_key, + _strict_response_validation=True, + http_client=httpx.Client(), + ), + ], + ids=["standard", "custom http client"], + ) + def test_base_url_trailing_slash(self, client: AgentexSDK) -> None: + request = client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + json_data={"foo": "bar"}, + ), + ) + assert request.url == "http://localhost:5000/custom/path/foo" + + @pytest.mark.parametrize( + "client", + [ + AgentexSDK( + base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True + ), + AgentexSDK( + base_url="http://localhost:5000/custom/path/", + api_key=api_key, + _strict_response_validation=True, + http_client=httpx.Client(), + ), + ], + ids=["standard", "custom http client"], + ) + def test_base_url_no_trailing_slash(self, client: AgentexSDK) -> None: + request = client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + json_data={"foo": "bar"}, + ), + ) + assert request.url == "http://localhost:5000/custom/path/foo" + + @pytest.mark.parametrize( + "client", + [ + AgentexSDK( + base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True + ), + AgentexSDK( + base_url="http://localhost:5000/custom/path/", + api_key=api_key, + _strict_response_validation=True, + http_client=httpx.Client(), + ), + ], + ids=["standard", "custom http client"], + ) + def test_absolute_request_url(self, client: AgentexSDK) -> None: + request = client._build_request( + FinalRequestOptions( + method="post", + url="https://myapi.com/foo", + json_data={"foo": "bar"}, + ), + ) + assert request.url == "https://myapi.com/foo" + + def test_copied_client_does_not_close_http(self) -> None: + client = AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + assert not client.is_closed() + + copied = client.copy() + assert copied is not client + + del copied + + assert not client.is_closed() + + def test_client_context_manager(self) -> None: + client = AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + with client as c2: + assert c2 is client + assert not c2.is_closed() + assert not client.is_closed() + assert client.is_closed() + + @pytest.mark.respx(base_url=base_url) + def test_client_response_validation_error(self, respx_mock: MockRouter) -> None: + class Model(BaseModel): + foo: str + + respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": {"invalid": True}})) + + with pytest.raises(APIResponseValidationError) as exc: + self.client.get("/foo", cast_to=Model) + + assert isinstance(exc.value.__cause__, ValidationError) + + def test_client_max_retries_validation(self) -> None: + with pytest.raises(TypeError, match=r"max_retries cannot be None"): + AgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, max_retries=cast(Any, None) + ) + + @pytest.mark.respx(base_url=base_url) + def test_received_text_for_expected_json(self, respx_mock: MockRouter) -> None: + class Model(BaseModel): + name: str + + respx_mock.get("/foo").mock(return_value=httpx.Response(200, text="my-custom-format")) + + strict_client = AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + + with pytest.raises(APIResponseValidationError): + strict_client.get("/foo", cast_to=Model) + + client = AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=False) + + response = client.get("/foo", cast_to=Model) + assert isinstance(response, str) # type: ignore[unreachable] + + @pytest.mark.parametrize( + "remaining_retries,retry_after,timeout", + [ + [3, "20", 20], + [3, "0", 0.5], + [3, "-10", 0.5], + [3, "60", 60], + [3, "61", 0.5], + [3, "Fri, 29 Sep 2023 16:26:57 GMT", 20], + [3, "Fri, 29 Sep 2023 16:26:37 GMT", 0.5], + [3, "Fri, 29 Sep 2023 16:26:27 GMT", 0.5], + [3, "Fri, 29 Sep 2023 16:27:37 GMT", 60], + [3, "Fri, 29 Sep 2023 16:27:38 GMT", 0.5], + [3, "99999999999999999999999999999999999", 0.5], + [3, "Zun, 29 Sep 2023 16:26:27 GMT", 0.5], + [3, "", 0.5], + [2, "", 0.5 * 2.0], + [1, "", 0.5 * 4.0], + [-1100, "", 8], # test large number potentially overflowing + ], + ) + @mock.patch("time.time", mock.MagicMock(return_value=1696004797)) + def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str, timeout: float) -> None: + client = AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + + headers = httpx.Headers({"retry-after": retry_after}) + options = FinalRequestOptions(method="get", url="/foo", max_retries=3) + calculated = client._calculate_retry_timeout(remaining_retries, options, headers) + assert calculated == pytest.approx(timeout, 0.5 * 0.875) # pyright: ignore[reportUnknownMemberType] + + @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @pytest.mark.respx(base_url=base_url) + def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter, client: AgentexSDK) -> None: + respx_mock.post("/echo").mock(side_effect=httpx.TimeoutException("Test timeout error")) + + with pytest.raises(APITimeoutError): + client.echo.with_streaming_response.send(message="message").__enter__() + + assert _get_open_connections(self.client) == 0 + + @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @pytest.mark.respx(base_url=base_url) + def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, client: AgentexSDK) -> None: + respx_mock.post("/echo").mock(return_value=httpx.Response(500)) + + with pytest.raises(APIStatusError): + client.echo.with_streaming_response.send(message="message").__enter__() + assert _get_open_connections(self.client) == 0 + + @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) + @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @pytest.mark.respx(base_url=base_url) + @pytest.mark.parametrize("failure_mode", ["status", "exception"]) + def test_retries_taken( + self, + client: AgentexSDK, + failures_before_success: int, + failure_mode: Literal["status", "exception"], + respx_mock: MockRouter, + ) -> None: + client = client.with_options(max_retries=4) + + nb_retries = 0 + + def retry_handler(_request: httpx.Request) -> httpx.Response: + nonlocal nb_retries + if nb_retries < failures_before_success: + nb_retries += 1 + if failure_mode == "exception": + raise RuntimeError("oops") + return httpx.Response(500) + return httpx.Response(200) + + respx_mock.post("/echo").mock(side_effect=retry_handler) + + response = client.echo.with_raw_response.send(message="message") + + assert response.retries_taken == failures_before_success + assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success + + @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) + @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @pytest.mark.respx(base_url=base_url) + def test_omit_retry_count_header( + self, client: AgentexSDK, failures_before_success: int, respx_mock: MockRouter + ) -> None: + client = client.with_options(max_retries=4) + + nb_retries = 0 + + def retry_handler(_request: httpx.Request) -> httpx.Response: + nonlocal nb_retries + if nb_retries < failures_before_success: + nb_retries += 1 + return httpx.Response(500) + return httpx.Response(200) + + respx_mock.post("/echo").mock(side_effect=retry_handler) + + response = client.echo.with_raw_response.send( + message="message", extra_headers={"x-stainless-retry-count": Omit()} + ) + + assert len(response.http_request.headers.get_list("x-stainless-retry-count")) == 0 + + @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) + @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @pytest.mark.respx(base_url=base_url) + def test_overwrite_retry_count_header( + self, client: AgentexSDK, failures_before_success: int, respx_mock: MockRouter + ) -> None: + client = client.with_options(max_retries=4) + + nb_retries = 0 + + def retry_handler(_request: httpx.Request) -> httpx.Response: + nonlocal nb_retries + if nb_retries < failures_before_success: + nb_retries += 1 + return httpx.Response(500) + return httpx.Response(200) + + respx_mock.post("/echo").mock(side_effect=retry_handler) + + response = client.echo.with_raw_response.send( + message="message", extra_headers={"x-stainless-retry-count": "42"} + ) + + assert response.http_request.headers.get("x-stainless-retry-count") == "42" + + def test_proxy_environment_variables(self, monkeypatch: pytest.MonkeyPatch) -> None: + # Test that the proxy environment variables are set correctly + monkeypatch.setenv("HTTPS_PROXY", "https://example.org") + + client = DefaultHttpxClient() + + mounts = tuple(client._mounts.items()) + assert len(mounts) == 1 + assert mounts[0][0].pattern == "https://" + + @pytest.mark.filterwarnings("ignore:.*deprecated.*:DeprecationWarning") + def test_default_client_creation(self) -> None: + # Ensure that the client can be initialized without any exceptions + DefaultHttpxClient( + verify=True, + cert=None, + trust_env=True, + http1=True, + http2=False, + limits=httpx.Limits(max_connections=100, max_keepalive_connections=20), + ) + + @pytest.mark.respx(base_url=base_url) + def test_follow_redirects(self, respx_mock: MockRouter) -> None: + # Test that the default follow_redirects=True allows following redirects + respx_mock.post("/redirect").mock( + return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"}) + ) + respx_mock.get("/redirected").mock(return_value=httpx.Response(200, json={"status": "ok"})) + + response = self.client.post("/redirect", body={"key": "value"}, cast_to=httpx.Response) + assert response.status_code == 200 + assert response.json() == {"status": "ok"} + + @pytest.mark.respx(base_url=base_url) + def test_follow_redirects_disabled(self, respx_mock: MockRouter) -> None: + # Test that follow_redirects=False prevents following redirects + respx_mock.post("/redirect").mock( + return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"}) + ) + + with pytest.raises(APIStatusError) as exc_info: + self.client.post( + "/redirect", body={"key": "value"}, options={"follow_redirects": False}, cast_to=httpx.Response + ) + + assert exc_info.value.response.status_code == 302 + assert exc_info.value.response.headers["Location"] == f"{base_url}/redirected" + + +class TestAsyncAgentexSDK: + client = AsyncAgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + + @pytest.mark.respx(base_url=base_url) + @pytest.mark.asyncio + async def test_raw_response(self, respx_mock: MockRouter) -> None: + respx_mock.post("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"})) + + response = await self.client.post("/foo", cast_to=httpx.Response) + assert response.status_code == 200 + assert isinstance(response, httpx.Response) + assert response.json() == {"foo": "bar"} + + @pytest.mark.respx(base_url=base_url) + @pytest.mark.asyncio + async def test_raw_response_for_binary(self, respx_mock: MockRouter) -> None: + respx_mock.post("/foo").mock( + return_value=httpx.Response(200, headers={"Content-Type": "application/binary"}, content='{"foo": "bar"}') + ) + + response = await self.client.post("/foo", cast_to=httpx.Response) + assert response.status_code == 200 + assert isinstance(response, httpx.Response) + assert response.json() == {"foo": "bar"} + + def test_copy(self) -> None: + copied = self.client.copy() + assert id(copied) != id(self.client) + + copied = self.client.copy(api_key="another My API Key") + assert copied.api_key == "another My API Key" + assert self.client.api_key == "My API Key" + + def test_copy_default_options(self) -> None: + # options that have a default are overridden correctly + copied = self.client.copy(max_retries=7) + assert copied.max_retries == 7 + assert self.client.max_retries == 2 + + copied2 = copied.copy(max_retries=6) + assert copied2.max_retries == 6 + assert copied.max_retries == 7 + + # timeout + assert isinstance(self.client.timeout, httpx.Timeout) + copied = self.client.copy(timeout=None) + assert copied.timeout is None + assert isinstance(self.client.timeout, httpx.Timeout) + + def test_copy_default_headers(self) -> None: + client = AsyncAgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} + ) + assert client.default_headers["X-Foo"] == "bar" + + # does not override the already given value when not specified + copied = client.copy() + assert copied.default_headers["X-Foo"] == "bar" + + # merges already given headers + copied = client.copy(default_headers={"X-Bar": "stainless"}) + assert copied.default_headers["X-Foo"] == "bar" + assert copied.default_headers["X-Bar"] == "stainless" + + # uses new values for any already given headers + copied = client.copy(default_headers={"X-Foo": "stainless"}) + assert copied.default_headers["X-Foo"] == "stainless" + + # set_default_headers + + # completely overrides already set values + copied = client.copy(set_default_headers={}) + assert copied.default_headers.get("X-Foo") is None + + copied = client.copy(set_default_headers={"X-Bar": "Robert"}) + assert copied.default_headers["X-Bar"] == "Robert" + + with pytest.raises( + ValueError, + match="`default_headers` and `set_default_headers` arguments are mutually exclusive", + ): + client.copy(set_default_headers={}, default_headers={"X-Foo": "Bar"}) + + def test_copy_default_query(self) -> None: + client = AsyncAgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"foo": "bar"} + ) + assert _get_params(client)["foo"] == "bar" + + # does not override the already given value when not specified + copied = client.copy() + assert _get_params(copied)["foo"] == "bar" + + # merges already given params + copied = client.copy(default_query={"bar": "stainless"}) + params = _get_params(copied) + assert params["foo"] == "bar" + assert params["bar"] == "stainless" + + # uses new values for any already given headers + copied = client.copy(default_query={"foo": "stainless"}) + assert _get_params(copied)["foo"] == "stainless" + + # set_default_query + + # completely overrides already set values + copied = client.copy(set_default_query={}) + assert _get_params(copied) == {} + + copied = client.copy(set_default_query={"bar": "Robert"}) + assert _get_params(copied)["bar"] == "Robert" + + with pytest.raises( + ValueError, + # TODO: update + match="`default_query` and `set_default_query` arguments are mutually exclusive", + ): + client.copy(set_default_query={}, default_query={"foo": "Bar"}) + + def test_copy_signature(self) -> None: + # ensure the same parameters that can be passed to the client are defined in the `.copy()` method + init_signature = inspect.signature( + # mypy doesn't like that we access the `__init__` property. + self.client.__init__, # type: ignore[misc] + ) + copy_signature = inspect.signature(self.client.copy) + exclude_params = {"transport", "proxies", "_strict_response_validation"} + + for name in init_signature.parameters.keys(): + if name in exclude_params: + continue + + copy_param = copy_signature.parameters.get(name) + assert copy_param is not None, f"copy() signature is missing the {name} param" + + @pytest.mark.skipif(sys.version_info >= (3, 10), reason="fails because of a memory leak that started from 3.12") + def test_copy_build_request(self) -> None: + options = FinalRequestOptions(method="get", url="/foo") + + def build_request(options: FinalRequestOptions) -> None: + client = self.client.copy() + client._build_request(options) + + # ensure that the machinery is warmed up before tracing starts. + build_request(options) + gc.collect() + + tracemalloc.start(1000) + + snapshot_before = tracemalloc.take_snapshot() + + ITERATIONS = 10 + for _ in range(ITERATIONS): + build_request(options) + + gc.collect() + snapshot_after = tracemalloc.take_snapshot() + + tracemalloc.stop() + + def add_leak(leaks: list[tracemalloc.StatisticDiff], diff: tracemalloc.StatisticDiff) -> None: + if diff.count == 0: + # Avoid false positives by considering only leaks (i.e. allocations that persist). + return + + if diff.count % ITERATIONS != 0: + # Avoid false positives by considering only leaks that appear per iteration. + return + + for frame in diff.traceback: + if any( + frame.filename.endswith(fragment) + for fragment in [ + # to_raw_response_wrapper leaks through the @functools.wraps() decorator. + # + # removing the decorator fixes the leak for reasons we don't understand. + "agentex_sdk/_legacy_response.py", + "agentex_sdk/_response.py", + # pydantic.BaseModel.model_dump || pydantic.BaseModel.dict leak memory for some reason. + "agentex_sdk/_compat.py", + # Standard library leaks we don't care about. + "/logging/__init__.py", + ] + ): + return + + leaks.append(diff) + + leaks: list[tracemalloc.StatisticDiff] = [] + for diff in snapshot_after.compare_to(snapshot_before, "traceback"): + add_leak(leaks, diff) + if leaks: + for leak in leaks: + print("MEMORY LEAK:", leak) + for frame in leak.traceback: + print(frame) + raise AssertionError() + + async def test_request_timeout(self) -> None: + request = self.client._build_request(FinalRequestOptions(method="get", url="/foo")) + timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore + assert timeout == DEFAULT_TIMEOUT + + request = self.client._build_request( + FinalRequestOptions(method="get", url="/foo", timeout=httpx.Timeout(100.0)) + ) + timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore + assert timeout == httpx.Timeout(100.0) + + async def test_client_timeout_option(self) -> None: + client = AsyncAgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, timeout=httpx.Timeout(0) + ) + + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore + assert timeout == httpx.Timeout(0) + + async def test_http_client_timeout_option(self) -> None: + # custom timeout given to the httpx client should be used + async with httpx.AsyncClient(timeout=None) as http_client: + client = AsyncAgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client + ) + + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore + assert timeout == httpx.Timeout(None) + + # no timeout given to the httpx client should not use the httpx default + async with httpx.AsyncClient() as http_client: + client = AsyncAgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client + ) + + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore + assert timeout == DEFAULT_TIMEOUT + + # explicitly passing the default timeout currently results in it being ignored + async with httpx.AsyncClient(timeout=HTTPX_DEFAULT_TIMEOUT) as http_client: + client = AsyncAgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client + ) + + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore + assert timeout == DEFAULT_TIMEOUT # our default + + def test_invalid_http_client(self) -> None: + with pytest.raises(TypeError, match="Invalid `http_client` arg"): + with httpx.Client() as http_client: + AsyncAgentexSDK( + base_url=base_url, + api_key=api_key, + _strict_response_validation=True, + http_client=cast(Any, http_client), + ) + + def test_default_headers_option(self) -> None: + client = AsyncAgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} + ) + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + assert request.headers.get("x-foo") == "bar" + assert request.headers.get("x-stainless-lang") == "python" + + client2 = AsyncAgentexSDK( + base_url=base_url, + api_key=api_key, + _strict_response_validation=True, + default_headers={ + "X-Foo": "stainless", + "X-Stainless-Lang": "my-overriding-header", + }, + ) + request = client2._build_request(FinalRequestOptions(method="get", url="/foo")) + assert request.headers.get("x-foo") == "stainless" + assert request.headers.get("x-stainless-lang") == "my-overriding-header" + + def test_validate_headers(self) -> None: + client = AsyncAgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + assert request.headers.get("Authorization") == f"Bearer {api_key}" + + with update_env(**{"AGENTEX_SDK_API_KEY": Omit()}): + client2 = AsyncAgentexSDK(base_url=base_url, api_key=None, _strict_response_validation=True) + + with pytest.raises( + TypeError, + match="Could not resolve authentication method. Expected the api_key to be set. Or for the `Authorization` headers to be explicitly omitted", + ): + client2._build_request(FinalRequestOptions(method="get", url="/foo")) + + request2 = client2._build_request( + FinalRequestOptions(method="get", url="/foo", headers={"Authorization": Omit()}) + ) + assert request2.headers.get("Authorization") is None + + def test_default_query_option(self) -> None: + client = AsyncAgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"query_param": "bar"} + ) + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + url = httpx.URL(request.url) + assert dict(url.params) == {"query_param": "bar"} + + request = client._build_request( + FinalRequestOptions( + method="get", + url="/foo", + params={"foo": "baz", "query_param": "overridden"}, + ) + ) + url = httpx.URL(request.url) + assert dict(url.params) == {"foo": "baz", "query_param": "overridden"} + + def test_request_extra_json(self) -> None: + request = self.client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + json_data={"foo": "bar"}, + extra_json={"baz": False}, + ), + ) + data = json.loads(request.content.decode("utf-8")) + assert data == {"foo": "bar", "baz": False} + + request = self.client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + extra_json={"baz": False}, + ), + ) + data = json.loads(request.content.decode("utf-8")) + assert data == {"baz": False} + + # `extra_json` takes priority over `json_data` when keys clash + request = self.client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + json_data={"foo": "bar", "baz": True}, + extra_json={"baz": None}, + ), + ) + data = json.loads(request.content.decode("utf-8")) + assert data == {"foo": "bar", "baz": None} + + def test_request_extra_headers(self) -> None: + request = self.client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + **make_request_options(extra_headers={"X-Foo": "Foo"}), + ), + ) + assert request.headers.get("X-Foo") == "Foo" + + # `extra_headers` takes priority over `default_headers` when keys clash + request = self.client.with_options(default_headers={"X-Bar": "true"})._build_request( + FinalRequestOptions( + method="post", + url="/foo", + **make_request_options( + extra_headers={"X-Bar": "false"}, + ), + ), + ) + assert request.headers.get("X-Bar") == "false" + + def test_request_extra_query(self) -> None: + request = self.client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + **make_request_options( + extra_query={"my_query_param": "Foo"}, + ), + ), + ) + params = dict(request.url.params) + assert params == {"my_query_param": "Foo"} + + # if both `query` and `extra_query` are given, they are merged + request = self.client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + **make_request_options( + query={"bar": "1"}, + extra_query={"foo": "2"}, + ), + ), + ) + params = dict(request.url.params) + assert params == {"bar": "1", "foo": "2"} + + # `extra_query` takes priority over `query` when keys clash + request = self.client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + **make_request_options( + query={"foo": "1"}, + extra_query={"foo": "2"}, + ), + ), + ) + params = dict(request.url.params) + assert params == {"foo": "2"} + + def test_multipart_repeating_array(self, async_client: AsyncAgentexSDK) -> None: + request = async_client._build_request( + FinalRequestOptions.construct( + method="post", + url="/foo", + headers={"Content-Type": "multipart/form-data; boundary=6b7ba517decee4a450543ea6ae821c82"}, + json_data={"array": ["foo", "bar"]}, + files=[("foo.txt", b"hello world")], + ) + ) + + assert request.read().split(b"\r\n") == [ + b"--6b7ba517decee4a450543ea6ae821c82", + b'Content-Disposition: form-data; name="array[]"', + b"", + b"foo", + b"--6b7ba517decee4a450543ea6ae821c82", + b'Content-Disposition: form-data; name="array[]"', + b"", + b"bar", + b"--6b7ba517decee4a450543ea6ae821c82", + b'Content-Disposition: form-data; name="foo.txt"; filename="upload"', + b"Content-Type: application/octet-stream", + b"", + b"hello world", + b"--6b7ba517decee4a450543ea6ae821c82--", + b"", + ] + + @pytest.mark.respx(base_url=base_url) + async def test_basic_union_response(self, respx_mock: MockRouter) -> None: + class Model1(BaseModel): + name: str + + class Model2(BaseModel): + foo: str + + respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"})) + + response = await self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) + assert isinstance(response, Model2) + assert response.foo == "bar" + + @pytest.mark.respx(base_url=base_url) + async def test_union_response_different_types(self, respx_mock: MockRouter) -> None: + """Union of objects with the same field name using a different type""" + + class Model1(BaseModel): + foo: int + + class Model2(BaseModel): + foo: str + + respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"})) + + response = await self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) + assert isinstance(response, Model2) + assert response.foo == "bar" + + respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": 1})) + + response = await self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) + assert isinstance(response, Model1) + assert response.foo == 1 + + @pytest.mark.respx(base_url=base_url) + async def test_non_application_json_content_type_for_json_data(self, respx_mock: MockRouter) -> None: + """ + Response that sets Content-Type to something other than application/json but returns json data + """ + + class Model(BaseModel): + foo: int + + respx_mock.get("/foo").mock( + return_value=httpx.Response( + 200, + content=json.dumps({"foo": 2}), + headers={"Content-Type": "application/text"}, + ) + ) + + response = await self.client.get("/foo", cast_to=Model) + assert isinstance(response, Model) + assert response.foo == 2 + + def test_base_url_setter(self) -> None: + client = AsyncAgentexSDK( + base_url="https://example.com/from_init", api_key=api_key, _strict_response_validation=True + ) + assert client.base_url == "https://example.com/from_init/" + + client.base_url = "https://example.com/from_setter" # type: ignore[assignment] + + assert client.base_url == "https://example.com/from_setter/" + + def test_base_url_env(self) -> None: + with update_env(AGENTEX_SDK_BASE_URL="http://localhost:5000/from/env"): + client = AsyncAgentexSDK(api_key=api_key, _strict_response_validation=True) + assert client.base_url == "http://localhost:5000/from/env/" + + @pytest.mark.parametrize( + "client", + [ + AsyncAgentexSDK( + base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True + ), + AsyncAgentexSDK( + base_url="http://localhost:5000/custom/path/", + api_key=api_key, + _strict_response_validation=True, + http_client=httpx.AsyncClient(), + ), + ], + ids=["standard", "custom http client"], + ) + def test_base_url_trailing_slash(self, client: AsyncAgentexSDK) -> None: + request = client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + json_data={"foo": "bar"}, + ), + ) + assert request.url == "http://localhost:5000/custom/path/foo" + + @pytest.mark.parametrize( + "client", + [ + AsyncAgentexSDK( + base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True + ), + AsyncAgentexSDK( + base_url="http://localhost:5000/custom/path/", + api_key=api_key, + _strict_response_validation=True, + http_client=httpx.AsyncClient(), + ), + ], + ids=["standard", "custom http client"], + ) + def test_base_url_no_trailing_slash(self, client: AsyncAgentexSDK) -> None: + request = client._build_request( + FinalRequestOptions( + method="post", + url="/foo", + json_data={"foo": "bar"}, + ), + ) + assert request.url == "http://localhost:5000/custom/path/foo" + + @pytest.mark.parametrize( + "client", + [ + AsyncAgentexSDK( + base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True + ), + AsyncAgentexSDK( + base_url="http://localhost:5000/custom/path/", + api_key=api_key, + _strict_response_validation=True, + http_client=httpx.AsyncClient(), + ), + ], + ids=["standard", "custom http client"], + ) + def test_absolute_request_url(self, client: AsyncAgentexSDK) -> None: + request = client._build_request( + FinalRequestOptions( + method="post", + url="https://myapi.com/foo", + json_data={"foo": "bar"}, + ), + ) + assert request.url == "https://myapi.com/foo" + + async def test_copied_client_does_not_close_http(self) -> None: + client = AsyncAgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + assert not client.is_closed() + + copied = client.copy() + assert copied is not client + + del copied + + await asyncio.sleep(0.2) + assert not client.is_closed() + + async def test_client_context_manager(self) -> None: + client = AsyncAgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + async with client as c2: + assert c2 is client + assert not c2.is_closed() + assert not client.is_closed() + assert client.is_closed() + + @pytest.mark.respx(base_url=base_url) + @pytest.mark.asyncio + async def test_client_response_validation_error(self, respx_mock: MockRouter) -> None: + class Model(BaseModel): + foo: str + + respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": {"invalid": True}})) + + with pytest.raises(APIResponseValidationError) as exc: + await self.client.get("/foo", cast_to=Model) + + assert isinstance(exc.value.__cause__, ValidationError) + + async def test_client_max_retries_validation(self) -> None: + with pytest.raises(TypeError, match=r"max_retries cannot be None"): + AsyncAgentexSDK( + base_url=base_url, api_key=api_key, _strict_response_validation=True, max_retries=cast(Any, None) + ) + + @pytest.mark.respx(base_url=base_url) + @pytest.mark.asyncio + async def test_received_text_for_expected_json(self, respx_mock: MockRouter) -> None: + class Model(BaseModel): + name: str + + respx_mock.get("/foo").mock(return_value=httpx.Response(200, text="my-custom-format")) + + strict_client = AsyncAgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + + with pytest.raises(APIResponseValidationError): + await strict_client.get("/foo", cast_to=Model) + + client = AsyncAgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=False) + + response = await client.get("/foo", cast_to=Model) + assert isinstance(response, str) # type: ignore[unreachable] + + @pytest.mark.parametrize( + "remaining_retries,retry_after,timeout", + [ + [3, "20", 20], + [3, "0", 0.5], + [3, "-10", 0.5], + [3, "60", 60], + [3, "61", 0.5], + [3, "Fri, 29 Sep 2023 16:26:57 GMT", 20], + [3, "Fri, 29 Sep 2023 16:26:37 GMT", 0.5], + [3, "Fri, 29 Sep 2023 16:26:27 GMT", 0.5], + [3, "Fri, 29 Sep 2023 16:27:37 GMT", 60], + [3, "Fri, 29 Sep 2023 16:27:38 GMT", 0.5], + [3, "99999999999999999999999999999999999", 0.5], + [3, "Zun, 29 Sep 2023 16:26:27 GMT", 0.5], + [3, "", 0.5], + [2, "", 0.5 * 2.0], + [1, "", 0.5 * 4.0], + [-1100, "", 8], # test large number potentially overflowing + ], + ) + @mock.patch("time.time", mock.MagicMock(return_value=1696004797)) + @pytest.mark.asyncio + async def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str, timeout: float) -> None: + client = AsyncAgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + + headers = httpx.Headers({"retry-after": retry_after}) + options = FinalRequestOptions(method="get", url="/foo", max_retries=3) + calculated = client._calculate_retry_timeout(remaining_retries, options, headers) + assert calculated == pytest.approx(timeout, 0.5 * 0.875) # pyright: ignore[reportUnknownMemberType] + + @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @pytest.mark.respx(base_url=base_url) + async def test_retrying_timeout_errors_doesnt_leak( + self, respx_mock: MockRouter, async_client: AsyncAgentexSDK + ) -> None: + respx_mock.post("/echo").mock(side_effect=httpx.TimeoutException("Test timeout error")) + + with pytest.raises(APITimeoutError): + await async_client.echo.with_streaming_response.send(message="message").__aenter__() + + assert _get_open_connections(self.client) == 0 + + @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @pytest.mark.respx(base_url=base_url) + async def test_retrying_status_errors_doesnt_leak( + self, respx_mock: MockRouter, async_client: AsyncAgentexSDK + ) -> None: + respx_mock.post("/echo").mock(return_value=httpx.Response(500)) + + with pytest.raises(APIStatusError): + await async_client.echo.with_streaming_response.send(message="message").__aenter__() + assert _get_open_connections(self.client) == 0 + + @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) + @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @pytest.mark.respx(base_url=base_url) + @pytest.mark.asyncio + @pytest.mark.parametrize("failure_mode", ["status", "exception"]) + async def test_retries_taken( + self, + async_client: AsyncAgentexSDK, + failures_before_success: int, + failure_mode: Literal["status", "exception"], + respx_mock: MockRouter, + ) -> None: + client = async_client.with_options(max_retries=4) + + nb_retries = 0 + + def retry_handler(_request: httpx.Request) -> httpx.Response: + nonlocal nb_retries + if nb_retries < failures_before_success: + nb_retries += 1 + if failure_mode == "exception": + raise RuntimeError("oops") + return httpx.Response(500) + return httpx.Response(200) + + respx_mock.post("/echo").mock(side_effect=retry_handler) + + response = await client.echo.with_raw_response.send(message="message") + + assert response.retries_taken == failures_before_success + assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success + + @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) + @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @pytest.mark.respx(base_url=base_url) + @pytest.mark.asyncio + async def test_omit_retry_count_header( + self, async_client: AsyncAgentexSDK, failures_before_success: int, respx_mock: MockRouter + ) -> None: + client = async_client.with_options(max_retries=4) + + nb_retries = 0 + + def retry_handler(_request: httpx.Request) -> httpx.Response: + nonlocal nb_retries + if nb_retries < failures_before_success: + nb_retries += 1 + return httpx.Response(500) + return httpx.Response(200) + + respx_mock.post("/echo").mock(side_effect=retry_handler) + + response = await client.echo.with_raw_response.send( + message="message", extra_headers={"x-stainless-retry-count": Omit()} + ) + + assert len(response.http_request.headers.get_list("x-stainless-retry-count")) == 0 + + @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) + @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @pytest.mark.respx(base_url=base_url) + @pytest.mark.asyncio + async def test_overwrite_retry_count_header( + self, async_client: AsyncAgentexSDK, failures_before_success: int, respx_mock: MockRouter + ) -> None: + client = async_client.with_options(max_retries=4) + + nb_retries = 0 + + def retry_handler(_request: httpx.Request) -> httpx.Response: + nonlocal nb_retries + if nb_retries < failures_before_success: + nb_retries += 1 + return httpx.Response(500) + return httpx.Response(200) + + respx_mock.post("/echo").mock(side_effect=retry_handler) + + response = await client.echo.with_raw_response.send( + message="message", extra_headers={"x-stainless-retry-count": "42"} + ) + + assert response.http_request.headers.get("x-stainless-retry-count") == "42" + + def test_get_platform(self) -> None: + # A previous implementation of asyncify could leave threads unterminated when + # used with nest_asyncio. + # + # Since nest_asyncio.apply() is global and cannot be un-applied, this + # test is run in a separate process to avoid affecting other tests. + test_code = dedent(""" + import asyncio + import nest_asyncio + import threading + + from agentex_sdk._utils import asyncify + from agentex_sdk._base_client import get_platform + + async def test_main() -> None: + result = await asyncify(get_platform)() + print(result) + for thread in threading.enumerate(): + print(thread.name) + + nest_asyncio.apply() + asyncio.run(test_main()) + """) + with subprocess.Popen( + [sys.executable, "-c", test_code], + text=True, + ) as process: + timeout = 10 # seconds + + start_time = time.monotonic() + while True: + return_code = process.poll() + if return_code is not None: + if return_code != 0: + raise AssertionError("calling get_platform using asyncify resulted in a non-zero exit code") + + # success + break + + if time.monotonic() - start_time > timeout: + process.kill() + raise AssertionError("calling get_platform using asyncify resulted in a hung process") + + time.sleep(0.1) + + async def test_proxy_environment_variables(self, monkeypatch: pytest.MonkeyPatch) -> None: + # Test that the proxy environment variables are set correctly + monkeypatch.setenv("HTTPS_PROXY", "https://example.org") + + client = DefaultAsyncHttpxClient() + + mounts = tuple(client._mounts.items()) + assert len(mounts) == 1 + assert mounts[0][0].pattern == "https://" + + @pytest.mark.filterwarnings("ignore:.*deprecated.*:DeprecationWarning") + async def test_default_client_creation(self) -> None: + # Ensure that the client can be initialized without any exceptions + DefaultAsyncHttpxClient( + verify=True, + cert=None, + trust_env=True, + http1=True, + http2=False, + limits=httpx.Limits(max_connections=100, max_keepalive_connections=20), + ) + + @pytest.mark.respx(base_url=base_url) + async def test_follow_redirects(self, respx_mock: MockRouter) -> None: + # Test that the default follow_redirects=True allows following redirects + respx_mock.post("/redirect").mock( + return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"}) + ) + respx_mock.get("/redirected").mock(return_value=httpx.Response(200, json={"status": "ok"})) + + response = await self.client.post("/redirect", body={"key": "value"}, cast_to=httpx.Response) + assert response.status_code == 200 + assert response.json() == {"status": "ok"} + + @pytest.mark.respx(base_url=base_url) + async def test_follow_redirects_disabled(self, respx_mock: MockRouter) -> None: + # Test that follow_redirects=False prevents following redirects + respx_mock.post("/redirect").mock( + return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"}) + ) + + with pytest.raises(APIStatusError) as exc_info: + await self.client.post( + "/redirect", body={"key": "value"}, options={"follow_redirects": False}, cast_to=httpx.Response + ) + + assert exc_info.value.response.status_code == 302 + assert exc_info.value.response.headers["Location"] == f"{base_url}/redirected" diff --git a/tests/test_deepcopy.py b/tests/test_deepcopy.py new file mode 100644 index 00000000..629bec1f --- /dev/null +++ b/tests/test_deepcopy.py @@ -0,0 +1,58 @@ +from agentex_sdk._utils import deepcopy_minimal + + +def assert_different_identities(obj1: object, obj2: object) -> None: + assert obj1 == obj2 + assert id(obj1) != id(obj2) + + +def test_simple_dict() -> None: + obj1 = {"foo": "bar"} + obj2 = deepcopy_minimal(obj1) + assert_different_identities(obj1, obj2) + + +def test_nested_dict() -> None: + obj1 = {"foo": {"bar": True}} + obj2 = deepcopy_minimal(obj1) + assert_different_identities(obj1, obj2) + assert_different_identities(obj1["foo"], obj2["foo"]) + + +def test_complex_nested_dict() -> None: + obj1 = {"foo": {"bar": [{"hello": "world"}]}} + obj2 = deepcopy_minimal(obj1) + assert_different_identities(obj1, obj2) + assert_different_identities(obj1["foo"], obj2["foo"]) + assert_different_identities(obj1["foo"]["bar"], obj2["foo"]["bar"]) + assert_different_identities(obj1["foo"]["bar"][0], obj2["foo"]["bar"][0]) + + +def test_simple_list() -> None: + obj1 = ["a", "b", "c"] + obj2 = deepcopy_minimal(obj1) + assert_different_identities(obj1, obj2) + + +def test_nested_list() -> None: + obj1 = ["a", [1, 2, 3]] + obj2 = deepcopy_minimal(obj1) + assert_different_identities(obj1, obj2) + assert_different_identities(obj1[1], obj2[1]) + + +class MyObject: ... + + +def test_ignores_other_types() -> None: + # custom classes + my_obj = MyObject() + obj1 = {"foo": my_obj} + obj2 = deepcopy_minimal(obj1) + assert_different_identities(obj1, obj2) + assert obj1["foo"] is my_obj + + # tuples + obj3 = ("a", "b") + obj4 = deepcopy_minimal(obj3) + assert obj3 is obj4 diff --git a/tests/test_extract_files.py b/tests/test_extract_files.py new file mode 100644 index 00000000..c01fa4ae --- /dev/null +++ b/tests/test_extract_files.py @@ -0,0 +1,64 @@ +from __future__ import annotations + +from typing import Sequence + +import pytest + +from agentex_sdk._types import FileTypes +from agentex_sdk._utils import extract_files + + +def test_removes_files_from_input() -> None: + query = {"foo": "bar"} + assert extract_files(query, paths=[]) == [] + assert query == {"foo": "bar"} + + query2 = {"foo": b"Bar", "hello": "world"} + assert extract_files(query2, paths=[["foo"]]) == [("foo", b"Bar")] + assert query2 == {"hello": "world"} + + query3 = {"foo": {"foo": {"bar": b"Bar"}}, "hello": "world"} + assert extract_files(query3, paths=[["foo", "foo", "bar"]]) == [("foo[foo][bar]", b"Bar")] + assert query3 == {"foo": {"foo": {}}, "hello": "world"} + + query4 = {"foo": {"bar": b"Bar", "baz": "foo"}, "hello": "world"} + assert extract_files(query4, paths=[["foo", "bar"]]) == [("foo[bar]", b"Bar")] + assert query4 == {"hello": "world", "foo": {"baz": "foo"}} + + +def test_multiple_files() -> None: + query = {"documents": [{"file": b"My first file"}, {"file": b"My second file"}]} + assert extract_files(query, paths=[["documents", "", "file"]]) == [ + ("documents[][file]", b"My first file"), + ("documents[][file]", b"My second file"), + ] + assert query == {"documents": [{}, {}]} + + +@pytest.mark.parametrize( + "query,paths,expected", + [ + [ + {"foo": {"bar": "baz"}}, + [["foo", "", "bar"]], + [], + ], + [ + {"foo": ["bar", "baz"]}, + [["foo", "bar"]], + [], + ], + [ + {"foo": {"bar": "baz"}}, + [["foo", "foo"]], + [], + ], + ], + ids=["dict expecting array", "array expecting dict", "unknown keys"], +) +def test_ignores_incorrect_paths( + query: dict[str, object], + paths: Sequence[Sequence[str]], + expected: list[tuple[str, FileTypes]], +) -> None: + assert extract_files(query, paths=paths) == expected diff --git a/tests/test_files.py b/tests/test_files.py new file mode 100644 index 00000000..f32d4061 --- /dev/null +++ b/tests/test_files.py @@ -0,0 +1,51 @@ +from pathlib import Path + +import anyio +import pytest +from dirty_equals import IsDict, IsList, IsBytes, IsTuple + +from agentex_sdk._files import to_httpx_files, async_to_httpx_files + +readme_path = Path(__file__).parent.parent.joinpath("README.md") + + +def test_pathlib_includes_file_name() -> None: + result = to_httpx_files({"file": readme_path}) + print(result) + assert result == IsDict({"file": IsTuple("README.md", IsBytes())}) + + +def test_tuple_input() -> None: + result = to_httpx_files([("file", readme_path)]) + print(result) + assert result == IsList(IsTuple("file", IsTuple("README.md", IsBytes()))) + + +@pytest.mark.asyncio +async def test_async_pathlib_includes_file_name() -> None: + result = await async_to_httpx_files({"file": readme_path}) + print(result) + assert result == IsDict({"file": IsTuple("README.md", IsBytes())}) + + +@pytest.mark.asyncio +async def test_async_supports_anyio_path() -> None: + result = await async_to_httpx_files({"file": anyio.Path(readme_path)}) + print(result) + assert result == IsDict({"file": IsTuple("README.md", IsBytes())}) + + +@pytest.mark.asyncio +async def test_async_tuple_input() -> None: + result = await async_to_httpx_files([("file", readme_path)]) + print(result) + assert result == IsList(IsTuple("file", IsTuple("README.md", IsBytes()))) + + +def test_string_not_allowed() -> None: + with pytest.raises(TypeError, match="Expected file types input to be a FileContent type or to be a tuple"): + to_httpx_files( + { + "file": "foo", # type: ignore + } + ) diff --git a/tests/test_models.py b/tests/test_models.py new file mode 100644 index 00000000..96e9e1c4 --- /dev/null +++ b/tests/test_models.py @@ -0,0 +1,936 @@ +import json +from typing import Any, Dict, List, Union, Optional, cast +from datetime import datetime, timezone +from typing_extensions import Literal, Annotated, TypeAliasType + +import pytest +import pydantic +from pydantic import Field + +from agentex_sdk._utils import PropertyInfo +from agentex_sdk._compat import PYDANTIC_V2, parse_obj, model_dump, model_json +from agentex_sdk._models import BaseModel, construct_type + + +class BasicModel(BaseModel): + foo: str + + +@pytest.mark.parametrize("value", ["hello", 1], ids=["correct type", "mismatched"]) +def test_basic(value: object) -> None: + m = BasicModel.construct(foo=value) + assert m.foo == value + + +def test_directly_nested_model() -> None: + class NestedModel(BaseModel): + nested: BasicModel + + m = NestedModel.construct(nested={"foo": "Foo!"}) + assert m.nested.foo == "Foo!" + + # mismatched types + m = NestedModel.construct(nested="hello!") + assert cast(Any, m.nested) == "hello!" + + +def test_optional_nested_model() -> None: + class NestedModel(BaseModel): + nested: Optional[BasicModel] + + m1 = NestedModel.construct(nested=None) + assert m1.nested is None + + m2 = NestedModel.construct(nested={"foo": "bar"}) + assert m2.nested is not None + assert m2.nested.foo == "bar" + + # mismatched types + m3 = NestedModel.construct(nested={"foo"}) + assert isinstance(cast(Any, m3.nested), set) + assert cast(Any, m3.nested) == {"foo"} + + +def test_list_nested_model() -> None: + class NestedModel(BaseModel): + nested: List[BasicModel] + + m = NestedModel.construct(nested=[{"foo": "bar"}, {"foo": "2"}]) + assert m.nested is not None + assert isinstance(m.nested, list) + assert len(m.nested) == 2 + assert m.nested[0].foo == "bar" + assert m.nested[1].foo == "2" + + # mismatched types + m = NestedModel.construct(nested=True) + assert cast(Any, m.nested) is True + + m = NestedModel.construct(nested=[False]) + assert cast(Any, m.nested) == [False] + + +def test_optional_list_nested_model() -> None: + class NestedModel(BaseModel): + nested: Optional[List[BasicModel]] + + m1 = NestedModel.construct(nested=[{"foo": "bar"}, {"foo": "2"}]) + assert m1.nested is not None + assert isinstance(m1.nested, list) + assert len(m1.nested) == 2 + assert m1.nested[0].foo == "bar" + assert m1.nested[1].foo == "2" + + m2 = NestedModel.construct(nested=None) + assert m2.nested is None + + # mismatched types + m3 = NestedModel.construct(nested={1}) + assert cast(Any, m3.nested) == {1} + + m4 = NestedModel.construct(nested=[False]) + assert cast(Any, m4.nested) == [False] + + +def test_list_optional_items_nested_model() -> None: + class NestedModel(BaseModel): + nested: List[Optional[BasicModel]] + + m = NestedModel.construct(nested=[None, {"foo": "bar"}]) + assert m.nested is not None + assert isinstance(m.nested, list) + assert len(m.nested) == 2 + assert m.nested[0] is None + assert m.nested[1] is not None + assert m.nested[1].foo == "bar" + + # mismatched types + m3 = NestedModel.construct(nested="foo") + assert cast(Any, m3.nested) == "foo" + + m4 = NestedModel.construct(nested=[False]) + assert cast(Any, m4.nested) == [False] + + +def test_list_mismatched_type() -> None: + class NestedModel(BaseModel): + nested: List[str] + + m = NestedModel.construct(nested=False) + assert cast(Any, m.nested) is False + + +def test_raw_dictionary() -> None: + class NestedModel(BaseModel): + nested: Dict[str, str] + + m = NestedModel.construct(nested={"hello": "world"}) + assert m.nested == {"hello": "world"} + + # mismatched types + m = NestedModel.construct(nested=False) + assert cast(Any, m.nested) is False + + +def test_nested_dictionary_model() -> None: + class NestedModel(BaseModel): + nested: Dict[str, BasicModel] + + m = NestedModel.construct(nested={"hello": {"foo": "bar"}}) + assert isinstance(m.nested, dict) + assert m.nested["hello"].foo == "bar" + + # mismatched types + m = NestedModel.construct(nested={"hello": False}) + assert cast(Any, m.nested["hello"]) is False + + +def test_unknown_fields() -> None: + m1 = BasicModel.construct(foo="foo", unknown=1) + assert m1.foo == "foo" + assert cast(Any, m1).unknown == 1 + + m2 = BasicModel.construct(foo="foo", unknown={"foo_bar": True}) + assert m2.foo == "foo" + assert cast(Any, m2).unknown == {"foo_bar": True} + + assert model_dump(m2) == {"foo": "foo", "unknown": {"foo_bar": True}} + + +def test_strict_validation_unknown_fields() -> None: + class Model(BaseModel): + foo: str + + model = parse_obj(Model, dict(foo="hello!", user="Robert")) + assert model.foo == "hello!" + assert cast(Any, model).user == "Robert" + + assert model_dump(model) == {"foo": "hello!", "user": "Robert"} + + +def test_aliases() -> None: + class Model(BaseModel): + my_field: int = Field(alias="myField") + + m = Model.construct(myField=1) + assert m.my_field == 1 + + # mismatched types + m = Model.construct(myField={"hello": False}) + assert cast(Any, m.my_field) == {"hello": False} + + +def test_repr() -> None: + model = BasicModel(foo="bar") + assert str(model) == "BasicModel(foo='bar')" + assert repr(model) == "BasicModel(foo='bar')" + + +def test_repr_nested_model() -> None: + class Child(BaseModel): + name: str + age: int + + class Parent(BaseModel): + name: str + child: Child + + model = Parent(name="Robert", child=Child(name="Foo", age=5)) + assert str(model) == "Parent(name='Robert', child=Child(name='Foo', age=5))" + assert repr(model) == "Parent(name='Robert', child=Child(name='Foo', age=5))" + + +def test_optional_list() -> None: + class Submodel(BaseModel): + name: str + + class Model(BaseModel): + items: Optional[List[Submodel]] + + m = Model.construct(items=None) + assert m.items is None + + m = Model.construct(items=[]) + assert m.items == [] + + m = Model.construct(items=[{"name": "Robert"}]) + assert m.items is not None + assert len(m.items) == 1 + assert m.items[0].name == "Robert" + + +def test_nested_union_of_models() -> None: + class Submodel1(BaseModel): + bar: bool + + class Submodel2(BaseModel): + thing: str + + class Model(BaseModel): + foo: Union[Submodel1, Submodel2] + + m = Model.construct(foo={"thing": "hello"}) + assert isinstance(m.foo, Submodel2) + assert m.foo.thing == "hello" + + +def test_nested_union_of_mixed_types() -> None: + class Submodel1(BaseModel): + bar: bool + + class Model(BaseModel): + foo: Union[Submodel1, Literal[True], Literal["CARD_HOLDER"]] + + m = Model.construct(foo=True) + assert m.foo is True + + m = Model.construct(foo="CARD_HOLDER") + assert m.foo == "CARD_HOLDER" + + m = Model.construct(foo={"bar": False}) + assert isinstance(m.foo, Submodel1) + assert m.foo.bar is False + + +def test_nested_union_multiple_variants() -> None: + class Submodel1(BaseModel): + bar: bool + + class Submodel2(BaseModel): + thing: str + + class Submodel3(BaseModel): + foo: int + + class Model(BaseModel): + foo: Union[Submodel1, Submodel2, None, Submodel3] + + m = Model.construct(foo={"thing": "hello"}) + assert isinstance(m.foo, Submodel2) + assert m.foo.thing == "hello" + + m = Model.construct(foo=None) + assert m.foo is None + + m = Model.construct() + assert m.foo is None + + m = Model.construct(foo={"foo": "1"}) + assert isinstance(m.foo, Submodel3) + assert m.foo.foo == 1 + + +def test_nested_union_invalid_data() -> None: + class Submodel1(BaseModel): + level: int + + class Submodel2(BaseModel): + name: str + + class Model(BaseModel): + foo: Union[Submodel1, Submodel2] + + m = Model.construct(foo=True) + assert cast(bool, m.foo) is True + + m = Model.construct(foo={"name": 3}) + if PYDANTIC_V2: + assert isinstance(m.foo, Submodel1) + assert m.foo.name == 3 # type: ignore + else: + assert isinstance(m.foo, Submodel2) + assert m.foo.name == "3" + + +def test_list_of_unions() -> None: + class Submodel1(BaseModel): + level: int + + class Submodel2(BaseModel): + name: str + + class Model(BaseModel): + items: List[Union[Submodel1, Submodel2]] + + m = Model.construct(items=[{"level": 1}, {"name": "Robert"}]) + assert len(m.items) == 2 + assert isinstance(m.items[0], Submodel1) + assert m.items[0].level == 1 + assert isinstance(m.items[1], Submodel2) + assert m.items[1].name == "Robert" + + m = Model.construct(items=[{"level": -1}, 156]) + assert len(m.items) == 2 + assert isinstance(m.items[0], Submodel1) + assert m.items[0].level == -1 + assert cast(Any, m.items[1]) == 156 + + +def test_union_of_lists() -> None: + class SubModel1(BaseModel): + level: int + + class SubModel2(BaseModel): + name: str + + class Model(BaseModel): + items: Union[List[SubModel1], List[SubModel2]] + + # with one valid entry + m = Model.construct(items=[{"name": "Robert"}]) + assert len(m.items) == 1 + assert isinstance(m.items[0], SubModel2) + assert m.items[0].name == "Robert" + + # with two entries pointing to different types + m = Model.construct(items=[{"level": 1}, {"name": "Robert"}]) + assert len(m.items) == 2 + assert isinstance(m.items[0], SubModel1) + assert m.items[0].level == 1 + assert isinstance(m.items[1], SubModel1) + assert cast(Any, m.items[1]).name == "Robert" + + # with two entries pointing to *completely* different types + m = Model.construct(items=[{"level": -1}, 156]) + assert len(m.items) == 2 + assert isinstance(m.items[0], SubModel1) + assert m.items[0].level == -1 + assert cast(Any, m.items[1]) == 156 + + +def test_dict_of_union() -> None: + class SubModel1(BaseModel): + name: str + + class SubModel2(BaseModel): + foo: str + + class Model(BaseModel): + data: Dict[str, Union[SubModel1, SubModel2]] + + m = Model.construct(data={"hello": {"name": "there"}, "foo": {"foo": "bar"}}) + assert len(list(m.data.keys())) == 2 + assert isinstance(m.data["hello"], SubModel1) + assert m.data["hello"].name == "there" + assert isinstance(m.data["foo"], SubModel2) + assert m.data["foo"].foo == "bar" + + # TODO: test mismatched type + + +def test_double_nested_union() -> None: + class SubModel1(BaseModel): + name: str + + class SubModel2(BaseModel): + bar: str + + class Model(BaseModel): + data: Dict[str, List[Union[SubModel1, SubModel2]]] + + m = Model.construct(data={"foo": [{"bar": "baz"}, {"name": "Robert"}]}) + assert len(m.data["foo"]) == 2 + + entry1 = m.data["foo"][0] + assert isinstance(entry1, SubModel2) + assert entry1.bar == "baz" + + entry2 = m.data["foo"][1] + assert isinstance(entry2, SubModel1) + assert entry2.name == "Robert" + + # TODO: test mismatched type + + +def test_union_of_dict() -> None: + class SubModel1(BaseModel): + name: str + + class SubModel2(BaseModel): + foo: str + + class Model(BaseModel): + data: Union[Dict[str, SubModel1], Dict[str, SubModel2]] + + m = Model.construct(data={"hello": {"name": "there"}, "foo": {"foo": "bar"}}) + assert len(list(m.data.keys())) == 2 + assert isinstance(m.data["hello"], SubModel1) + assert m.data["hello"].name == "there" + assert isinstance(m.data["foo"], SubModel1) + assert cast(Any, m.data["foo"]).foo == "bar" + + +def test_iso8601_datetime() -> None: + class Model(BaseModel): + created_at: datetime + + expected = datetime(2019, 12, 27, 18, 11, 19, 117000, tzinfo=timezone.utc) + + if PYDANTIC_V2: + expected_json = '{"created_at":"2019-12-27T18:11:19.117000Z"}' + else: + expected_json = '{"created_at": "2019-12-27T18:11:19.117000+00:00"}' + + model = Model.construct(created_at="2019-12-27T18:11:19.117Z") + assert model.created_at == expected + assert model_json(model) == expected_json + + model = parse_obj(Model, dict(created_at="2019-12-27T18:11:19.117Z")) + assert model.created_at == expected + assert model_json(model) == expected_json + + +def test_does_not_coerce_int() -> None: + class Model(BaseModel): + bar: int + + assert Model.construct(bar=1).bar == 1 + assert Model.construct(bar=10.9).bar == 10.9 + assert Model.construct(bar="19").bar == "19" # type: ignore[comparison-overlap] + assert Model.construct(bar=False).bar is False + + +def test_int_to_float_safe_conversion() -> None: + class Model(BaseModel): + float_field: float + + m = Model.construct(float_field=10) + assert m.float_field == 10.0 + assert isinstance(m.float_field, float) + + m = Model.construct(float_field=10.12) + assert m.float_field == 10.12 + assert isinstance(m.float_field, float) + + # number too big + m = Model.construct(float_field=2**53 + 1) + assert m.float_field == 2**53 + 1 + assert isinstance(m.float_field, int) + + +def test_deprecated_alias() -> None: + class Model(BaseModel): + resource_id: str = Field(alias="model_id") + + @property + def model_id(self) -> str: + return self.resource_id + + m = Model.construct(model_id="id") + assert m.model_id == "id" + assert m.resource_id == "id" + assert m.resource_id is m.model_id + + m = parse_obj(Model, {"model_id": "id"}) + assert m.model_id == "id" + assert m.resource_id == "id" + assert m.resource_id is m.model_id + + +def test_omitted_fields() -> None: + class Model(BaseModel): + resource_id: Optional[str] = None + + m = Model.construct() + assert m.resource_id is None + assert "resource_id" not in m.model_fields_set + + m = Model.construct(resource_id=None) + assert m.resource_id is None + assert "resource_id" in m.model_fields_set + + m = Model.construct(resource_id="foo") + assert m.resource_id == "foo" + assert "resource_id" in m.model_fields_set + + +def test_to_dict() -> None: + class Model(BaseModel): + foo: Optional[str] = Field(alias="FOO", default=None) + + m = Model(FOO="hello") + assert m.to_dict() == {"FOO": "hello"} + assert m.to_dict(use_api_names=False) == {"foo": "hello"} + + m2 = Model() + assert m2.to_dict() == {} + assert m2.to_dict(exclude_unset=False) == {"FOO": None} + assert m2.to_dict(exclude_unset=False, exclude_none=True) == {} + assert m2.to_dict(exclude_unset=False, exclude_defaults=True) == {} + + m3 = Model(FOO=None) + assert m3.to_dict() == {"FOO": None} + assert m3.to_dict(exclude_none=True) == {} + assert m3.to_dict(exclude_defaults=True) == {} + + class Model2(BaseModel): + created_at: datetime + + time_str = "2024-03-21T11:39:01.275859" + m4 = Model2.construct(created_at=time_str) + assert m4.to_dict(mode="python") == {"created_at": datetime.fromisoformat(time_str)} + assert m4.to_dict(mode="json") == {"created_at": time_str} + + if not PYDANTIC_V2: + with pytest.raises(ValueError, match="warnings is only supported in Pydantic v2"): + m.to_dict(warnings=False) + + +def test_forwards_compat_model_dump_method() -> None: + class Model(BaseModel): + foo: Optional[str] = Field(alias="FOO", default=None) + + m = Model(FOO="hello") + assert m.model_dump() == {"foo": "hello"} + assert m.model_dump(include={"bar"}) == {} + assert m.model_dump(exclude={"foo"}) == {} + assert m.model_dump(by_alias=True) == {"FOO": "hello"} + + m2 = Model() + assert m2.model_dump() == {"foo": None} + assert m2.model_dump(exclude_unset=True) == {} + assert m2.model_dump(exclude_none=True) == {} + assert m2.model_dump(exclude_defaults=True) == {} + + m3 = Model(FOO=None) + assert m3.model_dump() == {"foo": None} + assert m3.model_dump(exclude_none=True) == {} + + if not PYDANTIC_V2: + with pytest.raises(ValueError, match="round_trip is only supported in Pydantic v2"): + m.model_dump(round_trip=True) + + with pytest.raises(ValueError, match="warnings is only supported in Pydantic v2"): + m.model_dump(warnings=False) + + +def test_compat_method_no_error_for_warnings() -> None: + class Model(BaseModel): + foo: Optional[str] + + m = Model(foo="hello") + assert isinstance(model_dump(m, warnings=False), dict) + + +def test_to_json() -> None: + class Model(BaseModel): + foo: Optional[str] = Field(alias="FOO", default=None) + + m = Model(FOO="hello") + assert json.loads(m.to_json()) == {"FOO": "hello"} + assert json.loads(m.to_json(use_api_names=False)) == {"foo": "hello"} + + if PYDANTIC_V2: + assert m.to_json(indent=None) == '{"FOO":"hello"}' + else: + assert m.to_json(indent=None) == '{"FOO": "hello"}' + + m2 = Model() + assert json.loads(m2.to_json()) == {} + assert json.loads(m2.to_json(exclude_unset=False)) == {"FOO": None} + assert json.loads(m2.to_json(exclude_unset=False, exclude_none=True)) == {} + assert json.loads(m2.to_json(exclude_unset=False, exclude_defaults=True)) == {} + + m3 = Model(FOO=None) + assert json.loads(m3.to_json()) == {"FOO": None} + assert json.loads(m3.to_json(exclude_none=True)) == {} + + if not PYDANTIC_V2: + with pytest.raises(ValueError, match="warnings is only supported in Pydantic v2"): + m.to_json(warnings=False) + + +def test_forwards_compat_model_dump_json_method() -> None: + class Model(BaseModel): + foo: Optional[str] = Field(alias="FOO", default=None) + + m = Model(FOO="hello") + assert json.loads(m.model_dump_json()) == {"foo": "hello"} + assert json.loads(m.model_dump_json(include={"bar"})) == {} + assert json.loads(m.model_dump_json(include={"foo"})) == {"foo": "hello"} + assert json.loads(m.model_dump_json(by_alias=True)) == {"FOO": "hello"} + + assert m.model_dump_json(indent=2) == '{\n "foo": "hello"\n}' + + m2 = Model() + assert json.loads(m2.model_dump_json()) == {"foo": None} + assert json.loads(m2.model_dump_json(exclude_unset=True)) == {} + assert json.loads(m2.model_dump_json(exclude_none=True)) == {} + assert json.loads(m2.model_dump_json(exclude_defaults=True)) == {} + + m3 = Model(FOO=None) + assert json.loads(m3.model_dump_json()) == {"foo": None} + assert json.loads(m3.model_dump_json(exclude_none=True)) == {} + + if not PYDANTIC_V2: + with pytest.raises(ValueError, match="round_trip is only supported in Pydantic v2"): + m.model_dump_json(round_trip=True) + + with pytest.raises(ValueError, match="warnings is only supported in Pydantic v2"): + m.model_dump_json(warnings=False) + + +def test_type_compat() -> None: + # our model type can be assigned to Pydantic's model type + + def takes_pydantic(model: pydantic.BaseModel) -> None: # noqa: ARG001 + ... + + class OurModel(BaseModel): + foo: Optional[str] = None + + takes_pydantic(OurModel()) + + +def test_annotated_types() -> None: + class Model(BaseModel): + value: str + + m = construct_type( + value={"value": "foo"}, + type_=cast(Any, Annotated[Model, "random metadata"]), + ) + assert isinstance(m, Model) + assert m.value == "foo" + + +def test_discriminated_unions_invalid_data() -> None: + class A(BaseModel): + type: Literal["a"] + + data: str + + class B(BaseModel): + type: Literal["b"] + + data: int + + m = construct_type( + value={"type": "b", "data": "foo"}, + type_=cast(Any, Annotated[Union[A, B], PropertyInfo(discriminator="type")]), + ) + assert isinstance(m, B) + assert m.type == "b" + assert m.data == "foo" # type: ignore[comparison-overlap] + + m = construct_type( + value={"type": "a", "data": 100}, + type_=cast(Any, Annotated[Union[A, B], PropertyInfo(discriminator="type")]), + ) + assert isinstance(m, A) + assert m.type == "a" + if PYDANTIC_V2: + assert m.data == 100 # type: ignore[comparison-overlap] + else: + # pydantic v1 automatically converts inputs to strings + # if the expected type is a str + assert m.data == "100" + + +def test_discriminated_unions_unknown_variant() -> None: + class A(BaseModel): + type: Literal["a"] + + data: str + + class B(BaseModel): + type: Literal["b"] + + data: int + + m = construct_type( + value={"type": "c", "data": None, "new_thing": "bar"}, + type_=cast(Any, Annotated[Union[A, B], PropertyInfo(discriminator="type")]), + ) + + # just chooses the first variant + assert isinstance(m, A) + assert m.type == "c" # type: ignore[comparison-overlap] + assert m.data == None # type: ignore[unreachable] + assert m.new_thing == "bar" + + +def test_discriminated_unions_invalid_data_nested_unions() -> None: + class A(BaseModel): + type: Literal["a"] + + data: str + + class B(BaseModel): + type: Literal["b"] + + data: int + + class C(BaseModel): + type: Literal["c"] + + data: bool + + m = construct_type( + value={"type": "b", "data": "foo"}, + type_=cast(Any, Annotated[Union[Union[A, B], C], PropertyInfo(discriminator="type")]), + ) + assert isinstance(m, B) + assert m.type == "b" + assert m.data == "foo" # type: ignore[comparison-overlap] + + m = construct_type( + value={"type": "c", "data": "foo"}, + type_=cast(Any, Annotated[Union[Union[A, B], C], PropertyInfo(discriminator="type")]), + ) + assert isinstance(m, C) + assert m.type == "c" + assert m.data == "foo" # type: ignore[comparison-overlap] + + +def test_discriminated_unions_with_aliases_invalid_data() -> None: + class A(BaseModel): + foo_type: Literal["a"] = Field(alias="type") + + data: str + + class B(BaseModel): + foo_type: Literal["b"] = Field(alias="type") + + data: int + + m = construct_type( + value={"type": "b", "data": "foo"}, + type_=cast(Any, Annotated[Union[A, B], PropertyInfo(discriminator="foo_type")]), + ) + assert isinstance(m, B) + assert m.foo_type == "b" + assert m.data == "foo" # type: ignore[comparison-overlap] + + m = construct_type( + value={"type": "a", "data": 100}, + type_=cast(Any, Annotated[Union[A, B], PropertyInfo(discriminator="foo_type")]), + ) + assert isinstance(m, A) + assert m.foo_type == "a" + if PYDANTIC_V2: + assert m.data == 100 # type: ignore[comparison-overlap] + else: + # pydantic v1 automatically converts inputs to strings + # if the expected type is a str + assert m.data == "100" + + +def test_discriminated_unions_overlapping_discriminators_invalid_data() -> None: + class A(BaseModel): + type: Literal["a"] + + data: bool + + class B(BaseModel): + type: Literal["a"] + + data: int + + m = construct_type( + value={"type": "a", "data": "foo"}, + type_=cast(Any, Annotated[Union[A, B], PropertyInfo(discriminator="type")]), + ) + assert isinstance(m, B) + assert m.type == "a" + assert m.data == "foo" # type: ignore[comparison-overlap] + + +def test_discriminated_unions_invalid_data_uses_cache() -> None: + class A(BaseModel): + type: Literal["a"] + + data: str + + class B(BaseModel): + type: Literal["b"] + + data: int + + UnionType = cast(Any, Union[A, B]) + + assert not hasattr(UnionType, "__discriminator__") + + m = construct_type( + value={"type": "b", "data": "foo"}, type_=cast(Any, Annotated[UnionType, PropertyInfo(discriminator="type")]) + ) + assert isinstance(m, B) + assert m.type == "b" + assert m.data == "foo" # type: ignore[comparison-overlap] + + discriminator = UnionType.__discriminator__ + assert discriminator is not None + + m = construct_type( + value={"type": "b", "data": "foo"}, type_=cast(Any, Annotated[UnionType, PropertyInfo(discriminator="type")]) + ) + assert isinstance(m, B) + assert m.type == "b" + assert m.data == "foo" # type: ignore[comparison-overlap] + + # if the discriminator details object stays the same between invocations then + # we hit the cache + assert UnionType.__discriminator__ is discriminator + + +@pytest.mark.skipif(not PYDANTIC_V2, reason="TypeAliasType is not supported in Pydantic v1") +def test_type_alias_type() -> None: + Alias = TypeAliasType("Alias", str) # pyright: ignore + + class Model(BaseModel): + alias: Alias + union: Union[int, Alias] + + m = construct_type(value={"alias": "foo", "union": "bar"}, type_=Model) + assert isinstance(m, Model) + assert isinstance(m.alias, str) + assert m.alias == "foo" + assert isinstance(m.union, str) + assert m.union == "bar" + + +@pytest.mark.skipif(not PYDANTIC_V2, reason="TypeAliasType is not supported in Pydantic v1") +def test_field_named_cls() -> None: + class Model(BaseModel): + cls: str + + m = construct_type(value={"cls": "foo"}, type_=Model) + assert isinstance(m, Model) + assert isinstance(m.cls, str) + + +def test_discriminated_union_case() -> None: + class A(BaseModel): + type: Literal["a"] + + data: bool + + class B(BaseModel): + type: Literal["b"] + + data: List[Union[A, object]] + + class ModelA(BaseModel): + type: Literal["modelA"] + + data: int + + class ModelB(BaseModel): + type: Literal["modelB"] + + required: str + + data: Union[A, B] + + # when constructing ModelA | ModelB, value data doesn't match ModelB exactly - missing `required` + m = construct_type( + value={"type": "modelB", "data": {"type": "a", "data": True}}, + type_=cast(Any, Annotated[Union[ModelA, ModelB], PropertyInfo(discriminator="type")]), + ) + + assert isinstance(m, ModelB) + + +def test_nested_discriminated_union() -> None: + class InnerType1(BaseModel): + type: Literal["type_1"] + + class InnerModel(BaseModel): + inner_value: str + + class InnerType2(BaseModel): + type: Literal["type_2"] + some_inner_model: InnerModel + + class Type1(BaseModel): + base_type: Literal["base_type_1"] + value: Annotated[ + Union[ + InnerType1, + InnerType2, + ], + PropertyInfo(discriminator="type"), + ] + + class Type2(BaseModel): + base_type: Literal["base_type_2"] + + T = Annotated[ + Union[ + Type1, + Type2, + ], + PropertyInfo(discriminator="base_type"), + ] + + model = construct_type( + type_=T, + value={ + "base_type": "base_type_1", + "value": { + "type": "type_2", + }, + }, + ) + assert isinstance(model, Type1) + assert isinstance(model.value, InnerType2) diff --git a/tests/test_qs.py b/tests/test_qs.py new file mode 100644 index 00000000..998f6022 --- /dev/null +++ b/tests/test_qs.py @@ -0,0 +1,78 @@ +from typing import Any, cast +from functools import partial +from urllib.parse import unquote + +import pytest + +from agentex_sdk._qs import Querystring, stringify + + +def test_empty() -> None: + assert stringify({}) == "" + assert stringify({"a": {}}) == "" + assert stringify({"a": {"b": {"c": {}}}}) == "" + + +def test_basic() -> None: + assert stringify({"a": 1}) == "a=1" + assert stringify({"a": "b"}) == "a=b" + assert stringify({"a": True}) == "a=true" + assert stringify({"a": False}) == "a=false" + assert stringify({"a": 1.23456}) == "a=1.23456" + assert stringify({"a": None}) == "" + + +@pytest.mark.parametrize("method", ["class", "function"]) +def test_nested_dotted(method: str) -> None: + if method == "class": + serialise = Querystring(nested_format="dots").stringify + else: + serialise = partial(stringify, nested_format="dots") + + assert unquote(serialise({"a": {"b": "c"}})) == "a.b=c" + assert unquote(serialise({"a": {"b": "c", "d": "e", "f": "g"}})) == "a.b=c&a.d=e&a.f=g" + assert unquote(serialise({"a": {"b": {"c": {"d": "e"}}}})) == "a.b.c.d=e" + assert unquote(serialise({"a": {"b": True}})) == "a.b=true" + + +def test_nested_brackets() -> None: + assert unquote(stringify({"a": {"b": "c"}})) == "a[b]=c" + assert unquote(stringify({"a": {"b": "c", "d": "e", "f": "g"}})) == "a[b]=c&a[d]=e&a[f]=g" + assert unquote(stringify({"a": {"b": {"c": {"d": "e"}}}})) == "a[b][c][d]=e" + assert unquote(stringify({"a": {"b": True}})) == "a[b]=true" + + +@pytest.mark.parametrize("method", ["class", "function"]) +def test_array_comma(method: str) -> None: + if method == "class": + serialise = Querystring(array_format="comma").stringify + else: + serialise = partial(stringify, array_format="comma") + + assert unquote(serialise({"in": ["foo", "bar"]})) == "in=foo,bar" + assert unquote(serialise({"a": {"b": [True, False]}})) == "a[b]=true,false" + assert unquote(serialise({"a": {"b": [True, False, None, True]}})) == "a[b]=true,false,true" + + +def test_array_repeat() -> None: + assert unquote(stringify({"in": ["foo", "bar"]})) == "in=foo&in=bar" + assert unquote(stringify({"a": {"b": [True, False]}})) == "a[b]=true&a[b]=false" + assert unquote(stringify({"a": {"b": [True, False, None, True]}})) == "a[b]=true&a[b]=false&a[b]=true" + assert unquote(stringify({"in": ["foo", {"b": {"c": ["d", "e"]}}]})) == "in=foo&in[b][c]=d&in[b][c]=e" + + +@pytest.mark.parametrize("method", ["class", "function"]) +def test_array_brackets(method: str) -> None: + if method == "class": + serialise = Querystring(array_format="brackets").stringify + else: + serialise = partial(stringify, array_format="brackets") + + assert unquote(serialise({"in": ["foo", "bar"]})) == "in[]=foo&in[]=bar" + assert unquote(serialise({"a": {"b": [True, False]}})) == "a[b][]=true&a[b][]=false" + assert unquote(serialise({"a": {"b": [True, False, None, True]}})) == "a[b][]=true&a[b][]=false&a[b][]=true" + + +def test_unknown_array_format() -> None: + with pytest.raises(NotImplementedError, match="Unknown array_format value: foo, choose from comma, repeat"): + stringify({"a": ["foo", "bar"]}, array_format=cast(Any, "foo")) diff --git a/tests/test_required_args.py b/tests/test_required_args.py new file mode 100644 index 00000000..16023cc7 --- /dev/null +++ b/tests/test_required_args.py @@ -0,0 +1,111 @@ +from __future__ import annotations + +import pytest + +from agentex_sdk._utils import required_args + + +def test_too_many_positional_params() -> None: + @required_args(["a"]) + def foo(a: str | None = None) -> str | None: + return a + + with pytest.raises(TypeError, match=r"foo\(\) takes 1 argument\(s\) but 2 were given"): + foo("a", "b") # type: ignore + + +def test_positional_param() -> None: + @required_args(["a"]) + def foo(a: str | None = None) -> str | None: + return a + + assert foo("a") == "a" + assert foo(None) is None + assert foo(a="b") == "b" + + with pytest.raises(TypeError, match="Missing required argument: 'a'"): + foo() + + +def test_keyword_only_param() -> None: + @required_args(["a"]) + def foo(*, a: str | None = None) -> str | None: + return a + + assert foo(a="a") == "a" + assert foo(a=None) is None + assert foo(a="b") == "b" + + with pytest.raises(TypeError, match="Missing required argument: 'a'"): + foo() + + +def test_multiple_params() -> None: + @required_args(["a", "b", "c"]) + def foo(a: str = "", *, b: str = "", c: str = "") -> str | None: + return f"{a} {b} {c}" + + assert foo(a="a", b="b", c="c") == "a b c" + + error_message = r"Missing required arguments.*" + + with pytest.raises(TypeError, match=error_message): + foo() + + with pytest.raises(TypeError, match=error_message): + foo(a="a") + + with pytest.raises(TypeError, match=error_message): + foo(b="b") + + with pytest.raises(TypeError, match=error_message): + foo(c="c") + + with pytest.raises(TypeError, match=r"Missing required argument: 'a'"): + foo(b="a", c="c") + + with pytest.raises(TypeError, match=r"Missing required argument: 'b'"): + foo("a", c="c") + + +def test_multiple_variants() -> None: + @required_args(["a"], ["b"]) + def foo(*, a: str | None = None, b: str | None = None) -> str | None: + return a if a is not None else b + + assert foo(a="foo") == "foo" + assert foo(b="bar") == "bar" + assert foo(a=None) is None + assert foo(b=None) is None + + # TODO: this error message could probably be improved + with pytest.raises( + TypeError, + match=r"Missing required arguments; Expected either \('a'\) or \('b'\) arguments to be given", + ): + foo() + + +def test_multiple_params_multiple_variants() -> None: + @required_args(["a", "b"], ["c"]) + def foo(*, a: str | None = None, b: str | None = None, c: str | None = None) -> str | None: + if a is not None: + return a + if b is not None: + return b + return c + + error_message = r"Missing required arguments; Expected either \('a' and 'b'\) or \('c'\) arguments to be given" + + with pytest.raises(TypeError, match=error_message): + foo(a="foo") + + with pytest.raises(TypeError, match=error_message): + foo(b="bar") + + with pytest.raises(TypeError, match=error_message): + foo() + + assert foo(a=None, b="bar") == "bar" + assert foo(c=None) is None + assert foo(c="foo") == "foo" diff --git a/tests/test_response.py b/tests/test_response.py new file mode 100644 index 00000000..fb7b5b8c --- /dev/null +++ b/tests/test_response.py @@ -0,0 +1,277 @@ +import json +from typing import Any, List, Union, cast +from typing_extensions import Annotated + +import httpx +import pytest +import pydantic + +from agentex_sdk import BaseModel, AgentexSDK, AsyncAgentexSDK +from agentex_sdk._response import ( + APIResponse, + BaseAPIResponse, + AsyncAPIResponse, + BinaryAPIResponse, + AsyncBinaryAPIResponse, + extract_response_type, +) +from agentex_sdk._streaming import Stream +from agentex_sdk._base_client import FinalRequestOptions + + +class ConcreteBaseAPIResponse(APIResponse[bytes]): ... + + +class ConcreteAPIResponse(APIResponse[List[str]]): ... + + +class ConcreteAsyncAPIResponse(APIResponse[httpx.Response]): ... + + +def test_extract_response_type_direct_classes() -> None: + assert extract_response_type(BaseAPIResponse[str]) == str + assert extract_response_type(APIResponse[str]) == str + assert extract_response_type(AsyncAPIResponse[str]) == str + + +def test_extract_response_type_direct_class_missing_type_arg() -> None: + with pytest.raises( + RuntimeError, + match="Expected type to have a type argument at index 0 but it did not", + ): + extract_response_type(AsyncAPIResponse) + + +def test_extract_response_type_concrete_subclasses() -> None: + assert extract_response_type(ConcreteBaseAPIResponse) == bytes + assert extract_response_type(ConcreteAPIResponse) == List[str] + assert extract_response_type(ConcreteAsyncAPIResponse) == httpx.Response + + +def test_extract_response_type_binary_response() -> None: + assert extract_response_type(BinaryAPIResponse) == bytes + assert extract_response_type(AsyncBinaryAPIResponse) == bytes + + +class PydanticModel(pydantic.BaseModel): ... + + +def test_response_parse_mismatched_basemodel(client: AgentexSDK) -> None: + response = APIResponse( + raw=httpx.Response(200, content=b"foo"), + client=client, + stream=False, + stream_cls=None, + cast_to=str, + options=FinalRequestOptions.construct(method="get", url="/foo"), + ) + + with pytest.raises( + TypeError, + match="Pydantic models must subclass our base model type, e.g. `from agentex_sdk import BaseModel`", + ): + response.parse(to=PydanticModel) + + +@pytest.mark.asyncio +async def test_async_response_parse_mismatched_basemodel(async_client: AsyncAgentexSDK) -> None: + response = AsyncAPIResponse( + raw=httpx.Response(200, content=b"foo"), + client=async_client, + stream=False, + stream_cls=None, + cast_to=str, + options=FinalRequestOptions.construct(method="get", url="/foo"), + ) + + with pytest.raises( + TypeError, + match="Pydantic models must subclass our base model type, e.g. `from agentex_sdk import BaseModel`", + ): + await response.parse(to=PydanticModel) + + +def test_response_parse_custom_stream(client: AgentexSDK) -> None: + response = APIResponse( + raw=httpx.Response(200, content=b"foo"), + client=client, + stream=True, + stream_cls=None, + cast_to=str, + options=FinalRequestOptions.construct(method="get", url="/foo"), + ) + + stream = response.parse(to=Stream[int]) + assert stream._cast_to == int + + +@pytest.mark.asyncio +async def test_async_response_parse_custom_stream(async_client: AsyncAgentexSDK) -> None: + response = AsyncAPIResponse( + raw=httpx.Response(200, content=b"foo"), + client=async_client, + stream=True, + stream_cls=None, + cast_to=str, + options=FinalRequestOptions.construct(method="get", url="/foo"), + ) + + stream = await response.parse(to=Stream[int]) + assert stream._cast_to == int + + +class CustomModel(BaseModel): + foo: str + bar: int + + +def test_response_parse_custom_model(client: AgentexSDK) -> None: + response = APIResponse( + raw=httpx.Response(200, content=json.dumps({"foo": "hello!", "bar": 2})), + client=client, + stream=False, + stream_cls=None, + cast_to=str, + options=FinalRequestOptions.construct(method="get", url="/foo"), + ) + + obj = response.parse(to=CustomModel) + assert obj.foo == "hello!" + assert obj.bar == 2 + + +@pytest.mark.asyncio +async def test_async_response_parse_custom_model(async_client: AsyncAgentexSDK) -> None: + response = AsyncAPIResponse( + raw=httpx.Response(200, content=json.dumps({"foo": "hello!", "bar": 2})), + client=async_client, + stream=False, + stream_cls=None, + cast_to=str, + options=FinalRequestOptions.construct(method="get", url="/foo"), + ) + + obj = await response.parse(to=CustomModel) + assert obj.foo == "hello!" + assert obj.bar == 2 + + +def test_response_parse_annotated_type(client: AgentexSDK) -> None: + response = APIResponse( + raw=httpx.Response(200, content=json.dumps({"foo": "hello!", "bar": 2})), + client=client, + stream=False, + stream_cls=None, + cast_to=str, + options=FinalRequestOptions.construct(method="get", url="/foo"), + ) + + obj = response.parse( + to=cast("type[CustomModel]", Annotated[CustomModel, "random metadata"]), + ) + assert obj.foo == "hello!" + assert obj.bar == 2 + + +async def test_async_response_parse_annotated_type(async_client: AsyncAgentexSDK) -> None: + response = AsyncAPIResponse( + raw=httpx.Response(200, content=json.dumps({"foo": "hello!", "bar": 2})), + client=async_client, + stream=False, + stream_cls=None, + cast_to=str, + options=FinalRequestOptions.construct(method="get", url="/foo"), + ) + + obj = await response.parse( + to=cast("type[CustomModel]", Annotated[CustomModel, "random metadata"]), + ) + assert obj.foo == "hello!" + assert obj.bar == 2 + + +@pytest.mark.parametrize( + "content, expected", + [ + ("false", False), + ("true", True), + ("False", False), + ("True", True), + ("TrUe", True), + ("FalSe", False), + ], +) +def test_response_parse_bool(client: AgentexSDK, content: str, expected: bool) -> None: + response = APIResponse( + raw=httpx.Response(200, content=content), + client=client, + stream=False, + stream_cls=None, + cast_to=str, + options=FinalRequestOptions.construct(method="get", url="/foo"), + ) + + result = response.parse(to=bool) + assert result is expected + + +@pytest.mark.parametrize( + "content, expected", + [ + ("false", False), + ("true", True), + ("False", False), + ("True", True), + ("TrUe", True), + ("FalSe", False), + ], +) +async def test_async_response_parse_bool(client: AsyncAgentexSDK, content: str, expected: bool) -> None: + response = AsyncAPIResponse( + raw=httpx.Response(200, content=content), + client=client, + stream=False, + stream_cls=None, + cast_to=str, + options=FinalRequestOptions.construct(method="get", url="/foo"), + ) + + result = await response.parse(to=bool) + assert result is expected + + +class OtherModel(BaseModel): + a: str + + +@pytest.mark.parametrize("client", [False], indirect=True) # loose validation +def test_response_parse_expect_model_union_non_json_content(client: AgentexSDK) -> None: + response = APIResponse( + raw=httpx.Response(200, content=b"foo", headers={"Content-Type": "application/text"}), + client=client, + stream=False, + stream_cls=None, + cast_to=str, + options=FinalRequestOptions.construct(method="get", url="/foo"), + ) + + obj = response.parse(to=cast(Any, Union[CustomModel, OtherModel])) + assert isinstance(obj, str) + assert obj == "foo" + + +@pytest.mark.asyncio +@pytest.mark.parametrize("async_client", [False], indirect=True) # loose validation +async def test_async_response_parse_expect_model_union_non_json_content(async_client: AsyncAgentexSDK) -> None: + response = AsyncAPIResponse( + raw=httpx.Response(200, content=b"foo", headers={"Content-Type": "application/text"}), + client=async_client, + stream=False, + stream_cls=None, + cast_to=str, + options=FinalRequestOptions.construct(method="get", url="/foo"), + ) + + obj = await response.parse(to=cast(Any, Union[CustomModel, OtherModel])) + assert isinstance(obj, str) + assert obj == "foo" diff --git a/tests/test_streaming.py b/tests/test_streaming.py new file mode 100644 index 00000000..40d96b05 --- /dev/null +++ b/tests/test_streaming.py @@ -0,0 +1,250 @@ +from __future__ import annotations + +from typing import Iterator, AsyncIterator + +import httpx +import pytest + +from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from agentex_sdk._streaming import Stream, AsyncStream, ServerSentEvent + + +@pytest.mark.asyncio +@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) +async def test_basic(sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK) -> None: + def body() -> Iterator[bytes]: + yield b"event: completion\n" + yield b'data: {"foo":true}\n' + yield b"\n" + + iterator = make_event_iterator(content=body(), sync=sync, client=client, async_client=async_client) + + sse = await iter_next(iterator) + assert sse.event == "completion" + assert sse.json() == {"foo": True} + + await assert_empty_iter(iterator) + + +@pytest.mark.asyncio +@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) +async def test_data_missing_event(sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK) -> None: + def body() -> Iterator[bytes]: + yield b'data: {"foo":true}\n' + yield b"\n" + + iterator = make_event_iterator(content=body(), sync=sync, client=client, async_client=async_client) + + sse = await iter_next(iterator) + assert sse.event is None + assert sse.json() == {"foo": True} + + await assert_empty_iter(iterator) + + +@pytest.mark.asyncio +@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) +async def test_event_missing_data(sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK) -> None: + def body() -> Iterator[bytes]: + yield b"event: ping\n" + yield b"\n" + + iterator = make_event_iterator(content=body(), sync=sync, client=client, async_client=async_client) + + sse = await iter_next(iterator) + assert sse.event == "ping" + assert sse.data == "" + + await assert_empty_iter(iterator) + + +@pytest.mark.asyncio +@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) +async def test_multiple_events(sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK) -> None: + def body() -> Iterator[bytes]: + yield b"event: ping\n" + yield b"\n" + yield b"event: completion\n" + yield b"\n" + + iterator = make_event_iterator(content=body(), sync=sync, client=client, async_client=async_client) + + sse = await iter_next(iterator) + assert sse.event == "ping" + assert sse.data == "" + + sse = await iter_next(iterator) + assert sse.event == "completion" + assert sse.data == "" + + await assert_empty_iter(iterator) + + +@pytest.mark.asyncio +@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) +async def test_multiple_events_with_data(sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK) -> None: + def body() -> Iterator[bytes]: + yield b"event: ping\n" + yield b'data: {"foo":true}\n' + yield b"\n" + yield b"event: completion\n" + yield b'data: {"bar":false}\n' + yield b"\n" + + iterator = make_event_iterator(content=body(), sync=sync, client=client, async_client=async_client) + + sse = await iter_next(iterator) + assert sse.event == "ping" + assert sse.json() == {"foo": True} + + sse = await iter_next(iterator) + assert sse.event == "completion" + assert sse.json() == {"bar": False} + + await assert_empty_iter(iterator) + + +@pytest.mark.asyncio +@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) +async def test_multiple_data_lines_with_empty_line( + sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK +) -> None: + def body() -> Iterator[bytes]: + yield b"event: ping\n" + yield b"data: {\n" + yield b'data: "foo":\n' + yield b"data: \n" + yield b"data:\n" + yield b"data: true}\n" + yield b"\n\n" + + iterator = make_event_iterator(content=body(), sync=sync, client=client, async_client=async_client) + + sse = await iter_next(iterator) + assert sse.event == "ping" + assert sse.json() == {"foo": True} + assert sse.data == '{\n"foo":\n\n\ntrue}' + + await assert_empty_iter(iterator) + + +@pytest.mark.asyncio +@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) +async def test_data_json_escaped_double_new_line(sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK) -> None: + def body() -> Iterator[bytes]: + yield b"event: ping\n" + yield b'data: {"foo": "my long\\n\\ncontent"}' + yield b"\n\n" + + iterator = make_event_iterator(content=body(), sync=sync, client=client, async_client=async_client) + + sse = await iter_next(iterator) + assert sse.event == "ping" + assert sse.json() == {"foo": "my long\n\ncontent"} + + await assert_empty_iter(iterator) + + +@pytest.mark.asyncio +@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) +async def test_multiple_data_lines(sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK) -> None: + def body() -> Iterator[bytes]: + yield b"event: ping\n" + yield b"data: {\n" + yield b'data: "foo":\n' + yield b"data: true}\n" + yield b"\n\n" + + iterator = make_event_iterator(content=body(), sync=sync, client=client, async_client=async_client) + + sse = await iter_next(iterator) + assert sse.event == "ping" + assert sse.json() == {"foo": True} + + await assert_empty_iter(iterator) + + +@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) +async def test_special_new_line_character( + sync: bool, + client: AgentexSDK, + async_client: AsyncAgentexSDK, +) -> None: + def body() -> Iterator[bytes]: + yield b'data: {"content":" culpa"}\n' + yield b"\n" + yield b'data: {"content":" \xe2\x80\xa8"}\n' + yield b"\n" + yield b'data: {"content":"foo"}\n' + yield b"\n" + + iterator = make_event_iterator(content=body(), sync=sync, client=client, async_client=async_client) + + sse = await iter_next(iterator) + assert sse.event is None + assert sse.json() == {"content": " culpa"} + + sse = await iter_next(iterator) + assert sse.event is None + assert sse.json() == {"content": " 
"} + + sse = await iter_next(iterator) + assert sse.event is None + assert sse.json() == {"content": "foo"} + + await assert_empty_iter(iterator) + + +@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) +async def test_multi_byte_character_multiple_chunks( + sync: bool, + client: AgentexSDK, + async_client: AsyncAgentexSDK, +) -> None: + def body() -> Iterator[bytes]: + yield b'data: {"content":"' + # bytes taken from the string 'известни' and arbitrarily split + # so that some multi-byte characters span multiple chunks + yield b"\xd0" + yield b"\xb8\xd0\xb7\xd0" + yield b"\xb2\xd0\xb5\xd1\x81\xd1\x82\xd0\xbd\xd0\xb8" + yield b'"}\n' + yield b"\n" + + iterator = make_event_iterator(content=body(), sync=sync, client=client, async_client=async_client) + + sse = await iter_next(iterator) + assert sse.event is None + assert sse.json() == {"content": "известни"} + + +async def to_aiter(iter: Iterator[bytes]) -> AsyncIterator[bytes]: + for chunk in iter: + yield chunk + + +async def iter_next(iter: Iterator[ServerSentEvent] | AsyncIterator[ServerSentEvent]) -> ServerSentEvent: + if isinstance(iter, AsyncIterator): + return await iter.__anext__() + + return next(iter) + + +async def assert_empty_iter(iter: Iterator[ServerSentEvent] | AsyncIterator[ServerSentEvent]) -> None: + with pytest.raises((StopAsyncIteration, RuntimeError)): + await iter_next(iter) + + +def make_event_iterator( + content: Iterator[bytes], + *, + sync: bool, + client: AgentexSDK, + async_client: AsyncAgentexSDK, +) -> Iterator[ServerSentEvent] | AsyncIterator[ServerSentEvent]: + if sync: + return Stream(cast_to=object, client=client, response=httpx.Response(200, content=content))._iter_events() + + return AsyncStream( + cast_to=object, client=async_client, response=httpx.Response(200, content=to_aiter(content)) + )._iter_events() diff --git a/tests/test_transform.py b/tests/test_transform.py new file mode 100644 index 00000000..69920f1c --- /dev/null +++ b/tests/test_transform.py @@ -0,0 +1,453 @@ +from __future__ import annotations + +import io +import pathlib +from typing import Any, Dict, List, Union, TypeVar, Iterable, Optional, cast +from datetime import date, datetime +from typing_extensions import Required, Annotated, TypedDict + +import pytest + +from agentex_sdk._types import NOT_GIVEN, Base64FileInput +from agentex_sdk._utils import ( + PropertyInfo, + transform as _transform, + parse_datetime, + async_transform as _async_transform, +) +from agentex_sdk._compat import PYDANTIC_V2 +from agentex_sdk._models import BaseModel + +_T = TypeVar("_T") + +SAMPLE_FILE_PATH = pathlib.Path(__file__).parent.joinpath("sample_file.txt") + + +async def transform( + data: _T, + expected_type: object, + use_async: bool, +) -> _T: + if use_async: + return await _async_transform(data, expected_type=expected_type) + + return _transform(data, expected_type=expected_type) + + +parametrize = pytest.mark.parametrize("use_async", [False, True], ids=["sync", "async"]) + + +class Foo1(TypedDict): + foo_bar: Annotated[str, PropertyInfo(alias="fooBar")] + + +@parametrize +@pytest.mark.asyncio +async def test_top_level_alias(use_async: bool) -> None: + assert await transform({"foo_bar": "hello"}, expected_type=Foo1, use_async=use_async) == {"fooBar": "hello"} + + +class Foo2(TypedDict): + bar: Bar2 + + +class Bar2(TypedDict): + this_thing: Annotated[int, PropertyInfo(alias="this__thing")] + baz: Annotated[Baz2, PropertyInfo(alias="Baz")] + + +class Baz2(TypedDict): + my_baz: Annotated[str, PropertyInfo(alias="myBaz")] + + +@parametrize +@pytest.mark.asyncio +async def test_recursive_typeddict(use_async: bool) -> None: + assert await transform({"bar": {"this_thing": 1}}, Foo2, use_async) == {"bar": {"this__thing": 1}} + assert await transform({"bar": {"baz": {"my_baz": "foo"}}}, Foo2, use_async) == {"bar": {"Baz": {"myBaz": "foo"}}} + + +class Foo3(TypedDict): + things: List[Bar3] + + +class Bar3(TypedDict): + my_field: Annotated[str, PropertyInfo(alias="myField")] + + +@parametrize +@pytest.mark.asyncio +async def test_list_of_typeddict(use_async: bool) -> None: + result = await transform({"things": [{"my_field": "foo"}, {"my_field": "foo2"}]}, Foo3, use_async) + assert result == {"things": [{"myField": "foo"}, {"myField": "foo2"}]} + + +class Foo4(TypedDict): + foo: Union[Bar4, Baz4] + + +class Bar4(TypedDict): + foo_bar: Annotated[str, PropertyInfo(alias="fooBar")] + + +class Baz4(TypedDict): + foo_baz: Annotated[str, PropertyInfo(alias="fooBaz")] + + +@parametrize +@pytest.mark.asyncio +async def test_union_of_typeddict(use_async: bool) -> None: + assert await transform({"foo": {"foo_bar": "bar"}}, Foo4, use_async) == {"foo": {"fooBar": "bar"}} + assert await transform({"foo": {"foo_baz": "baz"}}, Foo4, use_async) == {"foo": {"fooBaz": "baz"}} + assert await transform({"foo": {"foo_baz": "baz", "foo_bar": "bar"}}, Foo4, use_async) == { + "foo": {"fooBaz": "baz", "fooBar": "bar"} + } + + +class Foo5(TypedDict): + foo: Annotated[Union[Bar4, List[Baz4]], PropertyInfo(alias="FOO")] + + +class Bar5(TypedDict): + foo_bar: Annotated[str, PropertyInfo(alias="fooBar")] + + +class Baz5(TypedDict): + foo_baz: Annotated[str, PropertyInfo(alias="fooBaz")] + + +@parametrize +@pytest.mark.asyncio +async def test_union_of_list(use_async: bool) -> None: + assert await transform({"foo": {"foo_bar": "bar"}}, Foo5, use_async) == {"FOO": {"fooBar": "bar"}} + assert await transform( + { + "foo": [ + {"foo_baz": "baz"}, + {"foo_baz": "baz"}, + ] + }, + Foo5, + use_async, + ) == {"FOO": [{"fooBaz": "baz"}, {"fooBaz": "baz"}]} + + +class Foo6(TypedDict): + bar: Annotated[str, PropertyInfo(alias="Bar")] + + +@parametrize +@pytest.mark.asyncio +async def test_includes_unknown_keys(use_async: bool) -> None: + assert await transform({"bar": "bar", "baz_": {"FOO": 1}}, Foo6, use_async) == { + "Bar": "bar", + "baz_": {"FOO": 1}, + } + + +class Foo7(TypedDict): + bar: Annotated[List[Bar7], PropertyInfo(alias="bAr")] + foo: Bar7 + + +class Bar7(TypedDict): + foo: str + + +@parametrize +@pytest.mark.asyncio +async def test_ignores_invalid_input(use_async: bool) -> None: + assert await transform({"bar": ""}, Foo7, use_async) == {"bAr": ""} + assert await transform({"foo": ""}, Foo7, use_async) == {"foo": ""} + + +class DatetimeDict(TypedDict, total=False): + foo: Annotated[datetime, PropertyInfo(format="iso8601")] + + bar: Annotated[Optional[datetime], PropertyInfo(format="iso8601")] + + required: Required[Annotated[Optional[datetime], PropertyInfo(format="iso8601")]] + + list_: Required[Annotated[Optional[List[datetime]], PropertyInfo(format="iso8601")]] + + union: Annotated[Union[int, datetime], PropertyInfo(format="iso8601")] + + +class DateDict(TypedDict, total=False): + foo: Annotated[date, PropertyInfo(format="iso8601")] + + +class DatetimeModel(BaseModel): + foo: datetime + + +class DateModel(BaseModel): + foo: Optional[date] + + +@parametrize +@pytest.mark.asyncio +async def test_iso8601_format(use_async: bool) -> None: + dt = datetime.fromisoformat("2023-02-23T14:16:36.337692+00:00") + tz = "Z" if PYDANTIC_V2 else "+00:00" + assert await transform({"foo": dt}, DatetimeDict, use_async) == {"foo": "2023-02-23T14:16:36.337692+00:00"} # type: ignore[comparison-overlap] + assert await transform(DatetimeModel(foo=dt), Any, use_async) == {"foo": "2023-02-23T14:16:36.337692" + tz} # type: ignore[comparison-overlap] + + dt = dt.replace(tzinfo=None) + assert await transform({"foo": dt}, DatetimeDict, use_async) == {"foo": "2023-02-23T14:16:36.337692"} # type: ignore[comparison-overlap] + assert await transform(DatetimeModel(foo=dt), Any, use_async) == {"foo": "2023-02-23T14:16:36.337692"} # type: ignore[comparison-overlap] + + assert await transform({"foo": None}, DateDict, use_async) == {"foo": None} # type: ignore[comparison-overlap] + assert await transform(DateModel(foo=None), Any, use_async) == {"foo": None} # type: ignore + assert await transform({"foo": date.fromisoformat("2023-02-23")}, DateDict, use_async) == {"foo": "2023-02-23"} # type: ignore[comparison-overlap] + assert await transform(DateModel(foo=date.fromisoformat("2023-02-23")), DateDict, use_async) == { + "foo": "2023-02-23" + } # type: ignore[comparison-overlap] + + +@parametrize +@pytest.mark.asyncio +async def test_optional_iso8601_format(use_async: bool) -> None: + dt = datetime.fromisoformat("2023-02-23T14:16:36.337692+00:00") + assert await transform({"bar": dt}, DatetimeDict, use_async) == {"bar": "2023-02-23T14:16:36.337692+00:00"} # type: ignore[comparison-overlap] + + assert await transform({"bar": None}, DatetimeDict, use_async) == {"bar": None} + + +@parametrize +@pytest.mark.asyncio +async def test_required_iso8601_format(use_async: bool) -> None: + dt = datetime.fromisoformat("2023-02-23T14:16:36.337692+00:00") + assert await transform({"required": dt}, DatetimeDict, use_async) == { + "required": "2023-02-23T14:16:36.337692+00:00" + } # type: ignore[comparison-overlap] + + assert await transform({"required": None}, DatetimeDict, use_async) == {"required": None} + + +@parametrize +@pytest.mark.asyncio +async def test_union_datetime(use_async: bool) -> None: + dt = datetime.fromisoformat("2023-02-23T14:16:36.337692+00:00") + assert await transform({"union": dt}, DatetimeDict, use_async) == { # type: ignore[comparison-overlap] + "union": "2023-02-23T14:16:36.337692+00:00" + } + + assert await transform({"union": "foo"}, DatetimeDict, use_async) == {"union": "foo"} + + +@parametrize +@pytest.mark.asyncio +async def test_nested_list_iso6801_format(use_async: bool) -> None: + dt1 = datetime.fromisoformat("2023-02-23T14:16:36.337692+00:00") + dt2 = parse_datetime("2022-01-15T06:34:23Z") + assert await transform({"list_": [dt1, dt2]}, DatetimeDict, use_async) == { # type: ignore[comparison-overlap] + "list_": ["2023-02-23T14:16:36.337692+00:00", "2022-01-15T06:34:23+00:00"] + } + + +@parametrize +@pytest.mark.asyncio +async def test_datetime_custom_format(use_async: bool) -> None: + dt = parse_datetime("2022-01-15T06:34:23Z") + + result = await transform(dt, Annotated[datetime, PropertyInfo(format="custom", format_template="%H")], use_async) + assert result == "06" # type: ignore[comparison-overlap] + + +class DateDictWithRequiredAlias(TypedDict, total=False): + required_prop: Required[Annotated[date, PropertyInfo(format="iso8601", alias="prop")]] + + +@parametrize +@pytest.mark.asyncio +async def test_datetime_with_alias(use_async: bool) -> None: + assert await transform({"required_prop": None}, DateDictWithRequiredAlias, use_async) == {"prop": None} # type: ignore[comparison-overlap] + assert await transform( + {"required_prop": date.fromisoformat("2023-02-23")}, DateDictWithRequiredAlias, use_async + ) == {"prop": "2023-02-23"} # type: ignore[comparison-overlap] + + +class MyModel(BaseModel): + foo: str + + +@parametrize +@pytest.mark.asyncio +async def test_pydantic_model_to_dictionary(use_async: bool) -> None: + assert cast(Any, await transform(MyModel(foo="hi!"), Any, use_async)) == {"foo": "hi!"} + assert cast(Any, await transform(MyModel.construct(foo="hi!"), Any, use_async)) == {"foo": "hi!"} + + +@parametrize +@pytest.mark.asyncio +async def test_pydantic_empty_model(use_async: bool) -> None: + assert cast(Any, await transform(MyModel.construct(), Any, use_async)) == {} + + +@parametrize +@pytest.mark.asyncio +async def test_pydantic_unknown_field(use_async: bool) -> None: + assert cast(Any, await transform(MyModel.construct(my_untyped_field=True), Any, use_async)) == { + "my_untyped_field": True + } + + +@parametrize +@pytest.mark.asyncio +async def test_pydantic_mismatched_types(use_async: bool) -> None: + model = MyModel.construct(foo=True) + if PYDANTIC_V2: + with pytest.warns(UserWarning): + params = await transform(model, Any, use_async) + else: + params = await transform(model, Any, use_async) + assert cast(Any, params) == {"foo": True} + + +@parametrize +@pytest.mark.asyncio +async def test_pydantic_mismatched_object_type(use_async: bool) -> None: + model = MyModel.construct(foo=MyModel.construct(hello="world")) + if PYDANTIC_V2: + with pytest.warns(UserWarning): + params = await transform(model, Any, use_async) + else: + params = await transform(model, Any, use_async) + assert cast(Any, params) == {"foo": {"hello": "world"}} + + +class ModelNestedObjects(BaseModel): + nested: MyModel + + +@parametrize +@pytest.mark.asyncio +async def test_pydantic_nested_objects(use_async: bool) -> None: + model = ModelNestedObjects.construct(nested={"foo": "stainless"}) + assert isinstance(model.nested, MyModel) + assert cast(Any, await transform(model, Any, use_async)) == {"nested": {"foo": "stainless"}} + + +class ModelWithDefaultField(BaseModel): + foo: str + with_none_default: Union[str, None] = None + with_str_default: str = "foo" + + +@parametrize +@pytest.mark.asyncio +async def test_pydantic_default_field(use_async: bool) -> None: + # should be excluded when defaults are used + model = ModelWithDefaultField.construct() + assert model.with_none_default is None + assert model.with_str_default == "foo" + assert cast(Any, await transform(model, Any, use_async)) == {} + + # should be included when the default value is explicitly given + model = ModelWithDefaultField.construct(with_none_default=None, with_str_default="foo") + assert model.with_none_default is None + assert model.with_str_default == "foo" + assert cast(Any, await transform(model, Any, use_async)) == {"with_none_default": None, "with_str_default": "foo"} + + # should be included when a non-default value is explicitly given + model = ModelWithDefaultField.construct(with_none_default="bar", with_str_default="baz") + assert model.with_none_default == "bar" + assert model.with_str_default == "baz" + assert cast(Any, await transform(model, Any, use_async)) == {"with_none_default": "bar", "with_str_default": "baz"} + + +class TypedDictIterableUnion(TypedDict): + foo: Annotated[Union[Bar8, Iterable[Baz8]], PropertyInfo(alias="FOO")] + + +class Bar8(TypedDict): + foo_bar: Annotated[str, PropertyInfo(alias="fooBar")] + + +class Baz8(TypedDict): + foo_baz: Annotated[str, PropertyInfo(alias="fooBaz")] + + +@parametrize +@pytest.mark.asyncio +async def test_iterable_of_dictionaries(use_async: bool) -> None: + assert await transform({"foo": [{"foo_baz": "bar"}]}, TypedDictIterableUnion, use_async) == { + "FOO": [{"fooBaz": "bar"}] + } + assert cast(Any, await transform({"foo": ({"foo_baz": "bar"},)}, TypedDictIterableUnion, use_async)) == { + "FOO": [{"fooBaz": "bar"}] + } + + def my_iter() -> Iterable[Baz8]: + yield {"foo_baz": "hello"} + yield {"foo_baz": "world"} + + assert await transform({"foo": my_iter()}, TypedDictIterableUnion, use_async) == { + "FOO": [{"fooBaz": "hello"}, {"fooBaz": "world"}] + } + + +@parametrize +@pytest.mark.asyncio +async def test_dictionary_items(use_async: bool) -> None: + class DictItems(TypedDict): + foo_baz: Annotated[str, PropertyInfo(alias="fooBaz")] + + assert await transform({"foo": {"foo_baz": "bar"}}, Dict[str, DictItems], use_async) == {"foo": {"fooBaz": "bar"}} + + +class TypedDictIterableUnionStr(TypedDict): + foo: Annotated[Union[str, Iterable[Baz8]], PropertyInfo(alias="FOO")] + + +@parametrize +@pytest.mark.asyncio +async def test_iterable_union_str(use_async: bool) -> None: + assert await transform({"foo": "bar"}, TypedDictIterableUnionStr, use_async) == {"FOO": "bar"} + assert cast(Any, await transform(iter([{"foo_baz": "bar"}]), Union[str, Iterable[Baz8]], use_async)) == [ + {"fooBaz": "bar"} + ] + + +class TypedDictBase64Input(TypedDict): + foo: Annotated[Union[str, Base64FileInput], PropertyInfo(format="base64")] + + +@parametrize +@pytest.mark.asyncio +async def test_base64_file_input(use_async: bool) -> None: + # strings are left as-is + assert await transform({"foo": "bar"}, TypedDictBase64Input, use_async) == {"foo": "bar"} + + # pathlib.Path is automatically converted to base64 + assert await transform({"foo": SAMPLE_FILE_PATH}, TypedDictBase64Input, use_async) == { + "foo": "SGVsbG8sIHdvcmxkIQo=" + } # type: ignore[comparison-overlap] + + # io instances are automatically converted to base64 + assert await transform({"foo": io.StringIO("Hello, world!")}, TypedDictBase64Input, use_async) == { + "foo": "SGVsbG8sIHdvcmxkIQ==" + } # type: ignore[comparison-overlap] + assert await transform({"foo": io.BytesIO(b"Hello, world!")}, TypedDictBase64Input, use_async) == { + "foo": "SGVsbG8sIHdvcmxkIQ==" + } # type: ignore[comparison-overlap] + + +@parametrize +@pytest.mark.asyncio +async def test_transform_skipping(use_async: bool) -> None: + # lists of ints are left as-is + data = [1, 2, 3] + assert await transform(data, List[int], use_async) is data + + # iterables of ints are converted to a list + data = iter([1, 2, 3]) + assert await transform(data, Iterable[int], use_async) == [1, 2, 3] + + +@parametrize +@pytest.mark.asyncio +async def test_strips_notgiven(use_async: bool) -> None: + assert await transform({"foo_bar": "bar"}, Foo1, use_async) == {"fooBar": "bar"} + assert await transform({"foo_bar": NOT_GIVEN}, Foo1, use_async) == {} diff --git a/tests/test_utils/test_proxy.py b/tests/test_utils/test_proxy.py new file mode 100644 index 00000000..7e7d0282 --- /dev/null +++ b/tests/test_utils/test_proxy.py @@ -0,0 +1,34 @@ +import operator +from typing import Any +from typing_extensions import override + +from agentex_sdk._utils import LazyProxy + + +class RecursiveLazyProxy(LazyProxy[Any]): + @override + def __load__(self) -> Any: + return self + + def __call__(self, *_args: Any, **_kwds: Any) -> Any: + raise RuntimeError("This should never be called!") + + +def test_recursive_proxy() -> None: + proxy = RecursiveLazyProxy() + assert repr(proxy) == "RecursiveLazyProxy" + assert str(proxy) == "RecursiveLazyProxy" + assert dir(proxy) == [] + assert type(proxy).__name__ == "RecursiveLazyProxy" + assert type(operator.attrgetter("name.foo.bar.baz")(proxy)).__name__ == "RecursiveLazyProxy" + + +def test_isinstance_does_not_error() -> None: + class AlwaysErrorProxy(LazyProxy[Any]): + @override + def __load__(self) -> Any: + raise RuntimeError("Mocking missing dependency") + + proxy = AlwaysErrorProxy() + assert not isinstance(proxy, dict) + assert isinstance(proxy, LazyProxy) diff --git a/tests/test_utils/test_typing.py b/tests/test_utils/test_typing.py new file mode 100644 index 00000000..1b29124b --- /dev/null +++ b/tests/test_utils/test_typing.py @@ -0,0 +1,73 @@ +from __future__ import annotations + +from typing import Generic, TypeVar, cast + +from agentex_sdk._utils import extract_type_var_from_base + +_T = TypeVar("_T") +_T2 = TypeVar("_T2") +_T3 = TypeVar("_T3") + + +class BaseGeneric(Generic[_T]): ... + + +class SubclassGeneric(BaseGeneric[_T]): ... + + +class BaseGenericMultipleTypeArgs(Generic[_T, _T2, _T3]): ... + + +class SubclassGenericMultipleTypeArgs(BaseGenericMultipleTypeArgs[_T, _T2, _T3]): ... + + +class SubclassDifferentOrderGenericMultipleTypeArgs(BaseGenericMultipleTypeArgs[_T2, _T, _T3]): ... + + +def test_extract_type_var() -> None: + assert ( + extract_type_var_from_base( + BaseGeneric[int], + index=0, + generic_bases=cast("tuple[type, ...]", (BaseGeneric,)), + ) + == int + ) + + +def test_extract_type_var_generic_subclass() -> None: + assert ( + extract_type_var_from_base( + SubclassGeneric[int], + index=0, + generic_bases=cast("tuple[type, ...]", (BaseGeneric,)), + ) + == int + ) + + +def test_extract_type_var_multiple() -> None: + typ = BaseGenericMultipleTypeArgs[int, str, None] + + generic_bases = cast("tuple[type, ...]", (BaseGenericMultipleTypeArgs,)) + assert extract_type_var_from_base(typ, index=0, generic_bases=generic_bases) == int + assert extract_type_var_from_base(typ, index=1, generic_bases=generic_bases) == str + assert extract_type_var_from_base(typ, index=2, generic_bases=generic_bases) == type(None) + + +def test_extract_type_var_generic_subclass_multiple() -> None: + typ = SubclassGenericMultipleTypeArgs[int, str, None] + + generic_bases = cast("tuple[type, ...]", (BaseGenericMultipleTypeArgs,)) + assert extract_type_var_from_base(typ, index=0, generic_bases=generic_bases) == int + assert extract_type_var_from_base(typ, index=1, generic_bases=generic_bases) == str + assert extract_type_var_from_base(typ, index=2, generic_bases=generic_bases) == type(None) + + +def test_extract_type_var_generic_subclass_different_ordering_multiple() -> None: + typ = SubclassDifferentOrderGenericMultipleTypeArgs[int, str, None] + + generic_bases = cast("tuple[type, ...]", (BaseGenericMultipleTypeArgs,)) + assert extract_type_var_from_base(typ, index=0, generic_bases=generic_bases) == int + assert extract_type_var_from_base(typ, index=1, generic_bases=generic_bases) == str + assert extract_type_var_from_base(typ, index=2, generic_bases=generic_bases) == type(None) diff --git a/tests/utils.py b/tests/utils.py new file mode 100644 index 00000000..d76528f0 --- /dev/null +++ b/tests/utils.py @@ -0,0 +1,159 @@ +from __future__ import annotations + +import os +import inspect +import traceback +import contextlib +from typing import Any, TypeVar, Iterator, cast +from datetime import date, datetime +from typing_extensions import Literal, get_args, get_origin, assert_type + +from agentex_sdk._types import Omit, NoneType +from agentex_sdk._utils import ( + is_dict, + is_list, + is_list_type, + is_union_type, + extract_type_arg, + is_annotated_type, + is_type_alias_type, +) +from agentex_sdk._compat import PYDANTIC_V2, field_outer_type, get_model_fields +from agentex_sdk._models import BaseModel + +BaseModelT = TypeVar("BaseModelT", bound=BaseModel) + + +def assert_matches_model(model: type[BaseModelT], value: BaseModelT, *, path: list[str]) -> bool: + for name, field in get_model_fields(model).items(): + field_value = getattr(value, name) + if PYDANTIC_V2: + allow_none = False + else: + # in v1 nullability was structured differently + # https://docs.pydantic.dev/2.0/migration/#required-optional-and-nullable-fields + allow_none = getattr(field, "allow_none", False) + + assert_matches_type( + field_outer_type(field), + field_value, + path=[*path, name], + allow_none=allow_none, + ) + + return True + + +# Note: the `path` argument is only used to improve error messages when `--showlocals` is used +def assert_matches_type( + type_: Any, + value: object, + *, + path: list[str], + allow_none: bool = False, +) -> None: + if is_type_alias_type(type_): + type_ = type_.__value__ + + # unwrap `Annotated[T, ...]` -> `T` + if is_annotated_type(type_): + type_ = extract_type_arg(type_, 0) + + if allow_none and value is None: + return + + if type_ is None or type_ is NoneType: + assert value is None + return + + origin = get_origin(type_) or type_ + + if is_list_type(type_): + return _assert_list_type(type_, value) + + if origin == str: + assert isinstance(value, str) + elif origin == int: + assert isinstance(value, int) + elif origin == bool: + assert isinstance(value, bool) + elif origin == float: + assert isinstance(value, float) + elif origin == bytes: + assert isinstance(value, bytes) + elif origin == datetime: + assert isinstance(value, datetime) + elif origin == date: + assert isinstance(value, date) + elif origin == object: + # nothing to do here, the expected type is unknown + pass + elif origin == Literal: + assert value in get_args(type_) + elif origin == dict: + assert is_dict(value) + + args = get_args(type_) + key_type = args[0] + items_type = args[1] + + for key, item in value.items(): + assert_matches_type(key_type, key, path=[*path, ""]) + assert_matches_type(items_type, item, path=[*path, ""]) + elif is_union_type(type_): + variants = get_args(type_) + + try: + none_index = variants.index(type(None)) + except ValueError: + pass + else: + # special case Optional[T] for better error messages + if len(variants) == 2: + if value is None: + # valid + return + + return assert_matches_type(type_=variants[not none_index], value=value, path=path) + + for i, variant in enumerate(variants): + try: + assert_matches_type(variant, value, path=[*path, f"variant {i}"]) + return + except AssertionError: + traceback.print_exc() + continue + + raise AssertionError("Did not match any variants") + elif issubclass(origin, BaseModel): + assert isinstance(value, type_) + assert assert_matches_model(type_, cast(Any, value), path=path) + elif inspect.isclass(origin) and origin.__name__ == "HttpxBinaryResponseContent": + assert value.__class__.__name__ == "HttpxBinaryResponseContent" + else: + assert None, f"Unhandled field type: {type_}" + + +def _assert_list_type(type_: type[object], value: object) -> None: + assert is_list(value) + + inner_type = get_args(type_)[0] + for entry in value: + assert_type(inner_type, entry) # type: ignore + + +@contextlib.contextmanager +def update_env(**new_env: str | Omit) -> Iterator[None]: + old = os.environ.copy() + + try: + for name, value in new_env.items(): + if isinstance(value, Omit): + os.environ.pop(name, None) + else: + os.environ[name] = value + + yield None + finally: + os.environ.clear() + os.environ.update(old) From 0fc9542634e88c7d9f6585acacb7c29a0500b31f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 16 Jul 2025 23:30:24 +0000 Subject: [PATCH 0003/1108] feat(api): update via SDK Studio --- .stats.yml | 4 +- api.md | 1 + src/agentex_sdk/resources/agents/agents.py | 109 ++++++++++++++++- src/agentex_sdk/types/__init__.py | 1 + src/agentex_sdk/types/agent_rpc_params.py | 85 +++++++++++++ tests/api_resources/test_agents.py | 135 ++++++++++++++++++++- 6 files changed, 330 insertions(+), 5 deletions(-) create mode 100644 src/agentex_sdk/types/agent_rpc_params.py diff --git a/.stats.yml b/.stats.yml index ee42a924..bb75ec7a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 35 +configured_endpoints: 36 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-7a38e3675674c19ea4fa2ca0cfef23aa1d96dbdb29ca3ba4194b0e858d0a4ee0.yml openapi_spec_hash: 55a7eae5bc606e4ac91841d7e675723e -config_hash: 2efc09afbaa8c5251e880538908bf4de +config_hash: fb0e10b3399899db49d43e9a59f20674 diff --git a/api.md b/api.md index f3554746..86560948 100644 --- a/api.md +++ b/api.md @@ -24,6 +24,7 @@ Methods: - client.agents.list(\*\*params) -> AgentListResponse - client.agents.delete(agent_id) -> Agent - client.agents.register(\*\*params) -> Agent +- client.agents.rpc(agent_id, \*\*params) -> object ## Name diff --git a/src/agentex_sdk/resources/agents/agents.py b/src/agentex_sdk/resources/agents/agents.py index 7b914d65..17642e0b 100644 --- a/src/agentex_sdk/resources/agents/agents.py +++ b/src/agentex_sdk/resources/agents/agents.py @@ -2,7 +2,8 @@ from __future__ import annotations -from typing import Optional +from typing import Union, Optional +from typing_extensions import Literal import httpx @@ -14,7 +15,7 @@ NameResourceWithStreamingResponse, AsyncNameResourceWithStreamingResponse, ) -from ...types import AcpType, agent_list_params, agent_register_params +from ...types import AcpType, agent_rpc_params, agent_list_params, agent_register_params from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property @@ -215,6 +216,52 @@ def register( cast_to=Agent, ) + def rpc( + self, + agent_id: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: agent_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> object: + """ + Handle JSON-RPC requests for an agent by its unique ID. + + Args: + 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 + """ + if not agent_id: + raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") + return self._post( + f"/agents/{agent_id}/rpc", + body=maybe_transform( + { + "method": method, + "params": params, + "id": id, + "jsonrpc": jsonrpc, + }, + agent_rpc_params.AgentRpcParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + ) + class AsyncAgentsResource(AsyncAPIResource): @cached_property @@ -398,6 +445,52 @@ async def register( cast_to=Agent, ) + async def rpc( + self, + agent_id: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: agent_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> object: + """ + Handle JSON-RPC requests for an agent by its unique ID. + + Args: + 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 + """ + if not agent_id: + raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") + return await self._post( + f"/agents/{agent_id}/rpc", + body=await async_maybe_transform( + { + "method": method, + "params": params, + "id": id, + "jsonrpc": jsonrpc, + }, + agent_rpc_params.AgentRpcParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + ) + class AgentsResourceWithRawResponse: def __init__(self, agents: AgentsResource) -> None: @@ -415,6 +508,9 @@ def __init__(self, agents: AgentsResource) -> None: self.register = to_raw_response_wrapper( agents.register, ) + self.rpc = to_raw_response_wrapper( + agents.rpc, + ) @cached_property def name(self) -> NameResourceWithRawResponse: @@ -437,6 +533,9 @@ def __init__(self, agents: AsyncAgentsResource) -> None: self.register = async_to_raw_response_wrapper( agents.register, ) + self.rpc = async_to_raw_response_wrapper( + agents.rpc, + ) @cached_property def name(self) -> AsyncNameResourceWithRawResponse: @@ -459,6 +558,9 @@ def __init__(self, agents: AgentsResource) -> None: self.register = to_streamed_response_wrapper( agents.register, ) + self.rpc = to_streamed_response_wrapper( + agents.rpc, + ) @cached_property def name(self) -> NameResourceWithStreamingResponse: @@ -481,6 +583,9 @@ def __init__(self, agents: AsyncAgentsResource) -> None: self.register = async_to_streamed_response_wrapper( agents.register, ) + self.rpc = async_to_streamed_response_wrapper( + agents.rpc, + ) @cached_property def name(self) -> AsyncNameResourceWithStreamingResponse: diff --git a/src/agentex_sdk/types/__init__.py b/src/agentex_sdk/types/__init__.py index 12a40c1b..5dc2f002 100644 --- a/src/agentex_sdk/types/__init__.py +++ b/src/agentex_sdk/types/__init__.py @@ -13,6 +13,7 @@ from .text_content import TextContent as TextContent from .message_style import MessageStyle as MessageStyle from .message_author import MessageAuthor as MessageAuthor +from .agent_rpc_params import AgentRpcParams as AgentRpcParams from .echo_send_params import EchoSendParams as EchoSendParams from .span_list_params import SpanListParams as SpanListParams from .streaming_status import StreamingStatus as StreamingStatus diff --git a/src/agentex_sdk/types/agent_rpc_params.py b/src/agentex_sdk/types/agent_rpc_params.py new file mode 100644 index 00000000..2c79a7a9 --- /dev/null +++ b/src/agentex_sdk/types/agent_rpc_params.py @@ -0,0 +1,85 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict, Union, Optional +from typing_extensions import Literal, Required, TypeAlias, TypedDict + +from .data_content_param import DataContentParam +from .text_content_param import TextContentParam +from .tool_request_content_param import ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam + +__all__ = [ + "AgentRpcParams", + "Params", + "ParamsCreateTaskRequest", + "ParamsCancelTaskRequest", + "ParamsSendMessageRequest", + "ParamsSendMessageRequestContent", + "ParamsSendEventRequest", + "ParamsSendEventRequestContent", +] + + +class AgentRpcParams(TypedDict, total=False): + method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] + + params: Required[Params] + + id: Union[int, str, None] + + jsonrpc: Literal["2.0"] + + +class ParamsCreateTaskRequest(TypedDict, total=False): + name: Optional[str] + """The name of the task to create""" + + params: Optional[Dict[str, object]] + """The parameters for the task""" + + +class ParamsCancelTaskRequest(TypedDict, total=False): + task_id: Optional[str] + """The ID of the task to cancel. Either this or task_name must be provided.""" + + task_name: Optional[str] + """The name of the task to cancel. Either this or task_id must be provided.""" + + +ParamsSendMessageRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendMessageRequest(TypedDict, total=False): + content: Required[ParamsSendMessageRequestContent] + """The message that was sent to the agent""" + + stream: bool + """Whether to stream the response message back to the client""" + + task_id: Optional[str] + """The ID of the task that the message was sent to""" + + +ParamsSendEventRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendEventRequest(TypedDict, total=False): + content: Optional[ParamsSendEventRequestContent] + """The content to send to the event""" + + task_id: Optional[str] + """The ID of the task that the event was sent to""" + + task_name: Optional[str] + """The name of the task that the event was sent to""" + + +Params: TypeAlias = Union[ + ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest +] diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index 094e6b19..f7072a9d 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -9,7 +9,10 @@ from agentex_sdk import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type -from agentex_sdk.types import Agent, AgentListResponse +from agentex_sdk.types import ( + Agent, + AgentListResponse, +) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -192,6 +195,71 @@ def test_streaming_response_register(self, client: AgentexSDK) -> None: assert cast(Any, response.is_closed) is True + @pytest.mark.skip() + @parametrize + def test_method_rpc(self, client: AgentexSDK) -> None: + agent = client.agents.rpc( + agent_id="agent_id", + method="event/send", + params={}, + ) + assert_matches_type(object, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_rpc_with_all_params(self, client: AgentexSDK) -> None: + agent = client.agents.rpc( + agent_id="agent_id", + method="event/send", + params={ + "name": "name", + "params": {"foo": "bar"}, + }, + id=0, + jsonrpc="2.0", + ) + assert_matches_type(object, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_rpc(self, client: AgentexSDK) -> None: + response = client.agents.with_raw_response.rpc( + agent_id="agent_id", + method="event/send", + params={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = response.parse() + assert_matches_type(object, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_rpc(self, client: AgentexSDK) -> None: + with client.agents.with_streaming_response.rpc( + agent_id="agent_id", + method="event/send", + params={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = response.parse() + assert_matches_type(object, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_rpc(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): + client.agents.with_raw_response.rpc( + agent_id="", + method="event/send", + params={}, + ) + class TestAsyncAgents: parametrize = pytest.mark.parametrize( @@ -372,3 +440,68 @@ async def test_streaming_response_register(self, async_client: AsyncAgentexSDK) assert_matches_type(Agent, agent, path=["response"]) assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_method_rpc(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.rpc( + agent_id="agent_id", + method="event/send", + params={}, + ) + assert_matches_type(object, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_rpc_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.rpc( + agent_id="agent_id", + method="event/send", + params={ + "name": "name", + "params": {"foo": "bar"}, + }, + id=0, + jsonrpc="2.0", + ) + assert_matches_type(object, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_rpc(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.agents.with_raw_response.rpc( + agent_id="agent_id", + method="event/send", + params={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = await response.parse() + assert_matches_type(object, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_rpc(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.agents.with_streaming_response.rpc( + agent_id="agent_id", + method="event/send", + params={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = await response.parse() + assert_matches_type(object, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_rpc(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): + await async_client.agents.with_raw_response.rpc( + agent_id="", + method="event/send", + params={}, + ) From f82fad55ebeaeecac0b04beb267aede0bdb242fa Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 16 Jul 2025 23:31:10 +0000 Subject: [PATCH 0004/1108] feat(api): update via SDK Studio --- .stats.yml | 2 +- api.md | 2 +- src/agentex_sdk/_decoders/jsonl.py | 123 +++++++ src/agentex_sdk/_response.py | 22 ++ src/agentex_sdk/resources/agents/agents.py | 283 +++++++++++------ src/agentex_sdk/types/__init__.py | 2 +- ...c_params.py => agent_handle_rpc_params.py} | 16 +- tests/api_resources/test_agents.py | 299 +++++++++++++----- tests/decoders/test_jsonl.py | 88 ++++++ 9 files changed, 657 insertions(+), 180 deletions(-) create mode 100644 src/agentex_sdk/_decoders/jsonl.py rename src/agentex_sdk/types/{agent_rpc_params.py => agent_handle_rpc_params.py} (85%) create mode 100644 tests/decoders/test_jsonl.py diff --git a/.stats.yml b/.stats.yml index bb75ec7a..a41c3504 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 36 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-7a38e3675674c19ea4fa2ca0cfef23aa1d96dbdb29ca3ba4194b0e858d0a4ee0.yml openapi_spec_hash: 55a7eae5bc606e4ac91841d7e675723e -config_hash: fb0e10b3399899db49d43e9a59f20674 +config_hash: bc7843ae93d8ed57135ad547127ba0f5 diff --git a/api.md b/api.md index 86560948..0fab860f 100644 --- a/api.md +++ b/api.md @@ -23,8 +23,8 @@ Methods: - client.agents.retrieve(agent_id) -> Agent - client.agents.list(\*\*params) -> AgentListResponse - client.agents.delete(agent_id) -> Agent +- client.agents.handle_rpc(agent_id, \*\*params) -> JSONLDecoder[object] - client.agents.register(\*\*params) -> Agent -- client.agents.rpc(agent_id, \*\*params) -> object ## Name diff --git a/src/agentex_sdk/_decoders/jsonl.py b/src/agentex_sdk/_decoders/jsonl.py new file mode 100644 index 00000000..ac5ac74f --- /dev/null +++ b/src/agentex_sdk/_decoders/jsonl.py @@ -0,0 +1,123 @@ +from __future__ import annotations + +import json +from typing_extensions import Generic, TypeVar, Iterator, AsyncIterator + +import httpx + +from .._models import construct_type_unchecked + +_T = TypeVar("_T") + + +class JSONLDecoder(Generic[_T]): + """A decoder for [JSON Lines](https://jsonlines.org) format. + + This class provides an iterator over a byte-iterator that parses each JSON Line + into a given type. + """ + + http_response: httpx.Response + """The HTTP response this decoder was constructed from""" + + def __init__( + self, + *, + raw_iterator: Iterator[bytes], + line_type: type[_T], + http_response: httpx.Response, + ) -> None: + super().__init__() + self.http_response = http_response + self._raw_iterator = raw_iterator + self._line_type = line_type + self._iterator = self.__decode__() + + def close(self) -> None: + """Close the response body stream. + + This is called automatically if you consume the entire stream. + """ + self.http_response.close() + + def __decode__(self) -> Iterator[_T]: + buf = b"" + for chunk in self._raw_iterator: + for line in chunk.splitlines(keepends=True): + buf += line + if buf.endswith((b"\r", b"\n", b"\r\n")): + yield construct_type_unchecked( + value=json.loads(buf), + type_=self._line_type, + ) + buf = b"" + + # flush + if buf: + yield construct_type_unchecked( + value=json.loads(buf), + type_=self._line_type, + ) + + def __next__(self) -> _T: + return self._iterator.__next__() + + def __iter__(self) -> Iterator[_T]: + for item in self._iterator: + yield item + + +class AsyncJSONLDecoder(Generic[_T]): + """A decoder for [JSON Lines](https://jsonlines.org) format. + + This class provides an async iterator over a byte-iterator that parses each JSON Line + into a given type. + """ + + http_response: httpx.Response + + def __init__( + self, + *, + raw_iterator: AsyncIterator[bytes], + line_type: type[_T], + http_response: httpx.Response, + ) -> None: + super().__init__() + self.http_response = http_response + self._raw_iterator = raw_iterator + self._line_type = line_type + self._iterator = self.__decode__() + + async def close(self) -> None: + """Close the response body stream. + + This is called automatically if you consume the entire stream. + """ + await self.http_response.aclose() + + async def __decode__(self) -> AsyncIterator[_T]: + buf = b"" + async for chunk in self._raw_iterator: + for line in chunk.splitlines(keepends=True): + buf += line + if buf.endswith((b"\r", b"\n", b"\r\n")): + yield construct_type_unchecked( + value=json.loads(buf), + type_=self._line_type, + ) + buf = b"" + + # flush + if buf: + yield construct_type_unchecked( + value=json.loads(buf), + type_=self._line_type, + ) + + async def __anext__(self) -> _T: + return await self._iterator.__anext__() + + async def __aiter__(self) -> AsyncIterator[_T]: + async for item in self._iterator: + yield item diff --git a/src/agentex_sdk/_response.py b/src/agentex_sdk/_response.py index d8115d31..3caafa10 100644 --- a/src/agentex_sdk/_response.py +++ b/src/agentex_sdk/_response.py @@ -30,6 +30,7 @@ from ._constants import RAW_RESPONSE_HEADER, OVERRIDE_CAST_TO_HEADER from ._streaming import Stream, AsyncStream, is_stream_class_type, extract_stream_chunk_type from ._exceptions import AgentexSDKError, APIResponseValidationError +from ._decoders.jsonl import JSONLDecoder, AsyncJSONLDecoder if TYPE_CHECKING: from ._models import FinalRequestOptions @@ -138,6 +139,27 @@ def _parse(self, *, to: type[_T] | None = None) -> R | _T: origin = get_origin(cast_to) or cast_to + if inspect.isclass(origin): + if issubclass(cast(Any, origin), JSONLDecoder): + return cast( + R, + cast("type[JSONLDecoder[Any]]", cast_to)( + raw_iterator=self.http_response.iter_bytes(chunk_size=64), + line_type=extract_type_arg(cast_to, 0), + http_response=self.http_response, + ), + ) + + if issubclass(cast(Any, origin), AsyncJSONLDecoder): + return cast( + R, + cast("type[AsyncJSONLDecoder[Any]]", cast_to)( + raw_iterator=self.http_response.aiter_bytes(chunk_size=64), + line_type=extract_type_arg(cast_to, 0), + http_response=self.http_response, + ), + ) + if self._is_sse_stream: if to: if not is_stream_class_type(to): diff --git a/src/agentex_sdk/resources/agents/agents.py b/src/agentex_sdk/resources/agents/agents.py index 17642e0b..0f2f45d2 100644 --- a/src/agentex_sdk/resources/agents/agents.py +++ b/src/agentex_sdk/resources/agents/agents.py @@ -3,7 +3,7 @@ from __future__ import annotations from typing import Union, Optional -from typing_extensions import Literal +from typing_extensions import Literal, overload import httpx @@ -15,9 +15,9 @@ NameResourceWithStreamingResponse, AsyncNameResourceWithStreamingResponse, ) -from ...types import AcpType, agent_rpc_params, agent_list_params, agent_register_params +from ...types import AcpType, agent_list_params, agent_register_params, agent_handle_rpc_params from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from ..._utils import maybe_transform, async_maybe_transform +from ..._utils import required_args, maybe_transform, async_maybe_transform from ..._compat import cached_property from ..._resource import SyncAPIResource, AsyncAPIResource from ..._response import ( @@ -29,6 +29,7 @@ from ...types.agent import Agent from ..._base_client import make_request_options from ...types.acp_type import AcpType +from ..._decoders.jsonl import JSONLDecoder, AsyncJSONLDecoder from ...types.agent_list_response import AgentListResponse __all__ = ["AgentsResource", "AsyncAgentsResource"] @@ -161,35 +162,56 @@ def delete( cast_to=Agent, ) - def register( + @overload + def handle_rpc( self, + agent_id: str, *, - acp_type: AcpType, - acp_url: str, - description: str, - name: str, - agent_id: Optional[str] | NotGiven = NOT_GIVEN, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: agent_handle_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # 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, - ) -> Agent: + ) -> JSONLDecoder[object]: """ - Register a new agent or update an existing one. + Handle JSON-RPC requests for an agent by its unique ID. Args: - acp_type: The type of ACP to use for the agent. + extra_headers: Send extra headers - acp_url: The URL of the ACP server for the agent. + extra_query: Add additional query parameters to the request - description: The description of the agent. + extra_body: Add additional JSON properties to the request - name: The unique name of the agent. + timeout: Override the client-level default timeout for this request, in seconds + """ + ... - agent_id: Optional agent ID if the agent already exists and needs to be updated. + @overload + def handle_rpc( + self, + agent_id: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: agent_handle_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> JSONLDecoder[object]: + """ + Handle JSON-RPC requests for an agent by its unique ID. + Args: extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -198,43 +220,73 @@ def register( timeout: Override the client-level default timeout for this request, in seconds """ + ... + + @required_args(["method", "params"]) + def handle_rpc( + self, + agent_id: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: agent_handle_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> JSONLDecoder[object] | JSONLDecoder[object]: + if not agent_id: + raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") return self._post( - "/agents/register", + f"/agents/{agent_id}/rpc", body=maybe_transform( { - "acp_type": acp_type, - "acp_url": acp_url, - "description": description, - "name": name, - "agent_id": agent_id, + "method": method, + "params": params, + "id": id, + "jsonrpc": jsonrpc, }, - agent_register_params.AgentRegisterParams, + agent_handle_rpc_params.AgentHandleRpcParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Agent, + cast_to=JSONLDecoder[object], + stream=todo_unsupported or False, ) - def rpc( + def register( self, - agent_id: str, *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + acp_type: AcpType, + acp_url: str, + description: str, + name: str, + agent_id: Optional[str] | NotGiven = NOT_GIVEN, # 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, - ) -> object: + ) -> Agent: """ - Handle JSON-RPC requests for an agent by its unique ID. + Register a new agent or update an existing one. Args: + acp_type: The type of ACP to use for the agent. + + acp_url: The URL of the ACP server for the agent. + + description: The description of the agent. + + name: The unique name of the agent. + + agent_id: Optional agent ID if the agent already exists and needs to be updated. + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -243,23 +295,22 @@ def rpc( timeout: Override the client-level default timeout for this request, in seconds """ - if not agent_id: - raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") return self._post( - f"/agents/{agent_id}/rpc", + "/agents/register", body=maybe_transform( { - "method": method, - "params": params, - "id": id, - "jsonrpc": jsonrpc, + "acp_type": acp_type, + "acp_url": acp_url, + "description": description, + "name": name, + "agent_id": agent_id, }, - agent_rpc_params.AgentRpcParams, + agent_register_params.AgentRegisterParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=object, + cast_to=Agent, ) @@ -390,35 +441,56 @@ async def delete( cast_to=Agent, ) - async def register( + @overload + async def handle_rpc( self, + agent_id: str, *, - acp_type: AcpType, - acp_url: str, - description: str, - name: str, - agent_id: Optional[str] | NotGiven = NOT_GIVEN, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: agent_handle_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # 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, - ) -> Agent: + ) -> AsyncJSONLDecoder[object]: """ - Register a new agent or update an existing one. + Handle JSON-RPC requests for an agent by its unique ID. Args: - acp_type: The type of ACP to use for the agent. + extra_headers: Send extra headers - acp_url: The URL of the ACP server for the agent. + extra_query: Add additional query parameters to the request - description: The description of the agent. + extra_body: Add additional JSON properties to the request - name: The unique name of the agent. + timeout: Override the client-level default timeout for this request, in seconds + """ + ... - agent_id: Optional agent ID if the agent already exists and needs to be updated. + @overload + async def handle_rpc( + self, + agent_id: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: agent_handle_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> AsyncJSONLDecoder[object]: + """ + Handle JSON-RPC requests for an agent by its unique ID. + Args: extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -427,43 +499,73 @@ async def register( timeout: Override the client-level default timeout for this request, in seconds """ + ... + + @required_args(["method", "params"]) + async def handle_rpc( + self, + agent_id: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: agent_handle_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> AsyncJSONLDecoder[object] | AsyncJSONLDecoder[object]: + if not agent_id: + raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") return await self._post( - "/agents/register", + f"/agents/{agent_id}/rpc", body=await async_maybe_transform( { - "acp_type": acp_type, - "acp_url": acp_url, - "description": description, - "name": name, - "agent_id": agent_id, + "method": method, + "params": params, + "id": id, + "jsonrpc": jsonrpc, }, - agent_register_params.AgentRegisterParams, + agent_handle_rpc_params.AgentHandleRpcParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Agent, + cast_to=AsyncJSONLDecoder[object], + stream=todo_unsupported or False, ) - async def rpc( + async def register( self, - agent_id: str, *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + acp_type: AcpType, + acp_url: str, + description: str, + name: str, + agent_id: Optional[str] | NotGiven = NOT_GIVEN, # 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, - ) -> object: + ) -> Agent: """ - Handle JSON-RPC requests for an agent by its unique ID. + Register a new agent or update an existing one. Args: + acp_type: The type of ACP to use for the agent. + + acp_url: The URL of the ACP server for the agent. + + description: The description of the agent. + + name: The unique name of the agent. + + agent_id: Optional agent ID if the agent already exists and needs to be updated. + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -472,23 +574,22 @@ async def rpc( timeout: Override the client-level default timeout for this request, in seconds """ - if not agent_id: - raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") return await self._post( - f"/agents/{agent_id}/rpc", + "/agents/register", body=await async_maybe_transform( { - "method": method, - "params": params, - "id": id, - "jsonrpc": jsonrpc, + "acp_type": acp_type, + "acp_url": acp_url, + "description": description, + "name": name, + "agent_id": agent_id, }, - agent_rpc_params.AgentRpcParams, + agent_register_params.AgentRegisterParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=object, + cast_to=Agent, ) @@ -505,12 +606,12 @@ def __init__(self, agents: AgentsResource) -> None: self.delete = to_raw_response_wrapper( agents.delete, ) + self.handle_rpc = to_raw_response_wrapper( + agents.handle_rpc, + ) self.register = to_raw_response_wrapper( agents.register, ) - self.rpc = to_raw_response_wrapper( - agents.rpc, - ) @cached_property def name(self) -> NameResourceWithRawResponse: @@ -530,12 +631,12 @@ def __init__(self, agents: AsyncAgentsResource) -> None: self.delete = async_to_raw_response_wrapper( agents.delete, ) + self.handle_rpc = async_to_raw_response_wrapper( + agents.handle_rpc, + ) self.register = async_to_raw_response_wrapper( agents.register, ) - self.rpc = async_to_raw_response_wrapper( - agents.rpc, - ) @cached_property def name(self) -> AsyncNameResourceWithRawResponse: @@ -555,12 +656,12 @@ def __init__(self, agents: AgentsResource) -> None: self.delete = to_streamed_response_wrapper( agents.delete, ) + self.handle_rpc = to_streamed_response_wrapper( + agents.handle_rpc, + ) self.register = to_streamed_response_wrapper( agents.register, ) - self.rpc = to_streamed_response_wrapper( - agents.rpc, - ) @cached_property def name(self) -> NameResourceWithStreamingResponse: @@ -580,12 +681,12 @@ def __init__(self, agents: AsyncAgentsResource) -> None: self.delete = async_to_streamed_response_wrapper( agents.delete, ) + self.handle_rpc = async_to_streamed_response_wrapper( + agents.handle_rpc, + ) self.register = async_to_streamed_response_wrapper( agents.register, ) - self.rpc = async_to_streamed_response_wrapper( - agents.rpc, - ) @cached_property def name(self) -> AsyncNameResourceWithStreamingResponse: diff --git a/src/agentex_sdk/types/__init__.py b/src/agentex_sdk/types/__init__.py index 5dc2f002..544c9db3 100644 --- a/src/agentex_sdk/types/__init__.py +++ b/src/agentex_sdk/types/__init__.py @@ -13,7 +13,6 @@ from .text_content import TextContent as TextContent from .message_style import MessageStyle as MessageStyle from .message_author import MessageAuthor as MessageAuthor -from .agent_rpc_params import AgentRpcParams as AgentRpcParams from .echo_send_params import EchoSendParams as EchoSendParams from .span_list_params import SpanListParams as SpanListParams from .streaming_status import StreamingStatus as StreamingStatus @@ -42,5 +41,6 @@ from .tool_response_content import ToolResponseContent as ToolResponseContent from .tracker_list_response import TrackerListResponse as TrackerListResponse from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams +from .agent_handle_rpc_params import AgentHandleRpcParams as AgentHandleRpcParams from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam diff --git a/src/agentex_sdk/types/agent_rpc_params.py b/src/agentex_sdk/types/agent_handle_rpc_params.py similarity index 85% rename from src/agentex_sdk/types/agent_rpc_params.py rename to src/agentex_sdk/types/agent_handle_rpc_params.py index 2c79a7a9..1d2d2233 100644 --- a/src/agentex_sdk/types/agent_rpc_params.py +++ b/src/agentex_sdk/types/agent_handle_rpc_params.py @@ -11,7 +11,7 @@ from .tool_response_content_param import ToolResponseContentParam __all__ = [ - "AgentRpcParams", + "AgentHandleRpcParamsBase", "Params", "ParamsCreateTaskRequest", "ParamsCancelTaskRequest", @@ -19,10 +19,11 @@ "ParamsSendMessageRequestContent", "ParamsSendEventRequest", "ParamsSendEventRequestContent", + "AgentHandleRpcParamsNonStreaming", ] -class AgentRpcParams(TypedDict, total=False): +class AgentHandleRpcParamsBase(TypedDict, total=False): method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] params: Required[Params] @@ -83,3 +84,14 @@ class ParamsSendEventRequest(TypedDict, total=False): Params: TypeAlias = Union[ ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest ] + + +class AgentHandleRpcParamsNonStreaming(AgentHandleRpcParamsBase, total=False): + pass + + +class AgentHandleRpcParamsNonStreaming(AgentHandleRpcParamsBase, total=False): + pass + + +AgentHandleRpcParams = Union[AgentHandleRpcParamsNonStreaming, AgentHandleRpcParamsNonStreaming] diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index f7072a9d..3b298619 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -13,6 +13,7 @@ Agent, AgentListResponse, ) +from agentex_sdk._decoders.jsonl import JSONLDecoder, AsyncJSONLDecoder base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -142,73 +143,83 @@ def test_path_params_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_register(self, client: AgentexSDK) -> None: - agent = client.agents.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", + def test_method_handle_rpc_overload_1(self, client: AgentexSDK) -> None: + agent = client.agents.handle_rpc( + agent_id="agent_id", + method="event/send", + params={}, ) - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(JSONLDecoder[object], agent, path=["response"]) @pytest.mark.skip() @parametrize - def test_method_register_with_all_params(self, client: AgentexSDK) -> None: - agent = client.agents.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", + def test_method_handle_rpc_with_all_params_overload_1(self, client: AgentexSDK) -> None: + agent = client.agents.handle_rpc( agent_id="agent_id", + method="event/send", + params={ + "name": "name", + "params": {"foo": "bar"}, + }, + id=0, + jsonrpc="2.0", ) - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(JSONLDecoder[object], agent, path=["response"]) @pytest.mark.skip() @parametrize - def test_raw_response_register(self, client: AgentexSDK) -> None: - response = client.agents.with_raw_response.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", + def test_raw_response_handle_rpc_overload_1(self, client: AgentexSDK) -> None: + response = client.agents.with_raw_response.handle_rpc( + agent_id="agent_id", + method="event/send", + params={}, ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(JSONLDecoder[object], agent, path=["response"]) @pytest.mark.skip() @parametrize - def test_streaming_response_register(self, client: AgentexSDK) -> None: - with client.agents.with_streaming_response.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", + def test_streaming_response_handle_rpc_overload_1(self, client: AgentexSDK) -> None: + with client.agents.with_streaming_response.handle_rpc( + agent_id="agent_id", + method="event/send", + params={}, ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(JSONLDecoder[object], agent, path=["response"]) assert cast(Any, response.is_closed) is True @pytest.mark.skip() @parametrize - def test_method_rpc(self, client: AgentexSDK) -> None: - agent = client.agents.rpc( + def test_path_params_handle_rpc_overload_1(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): + client.agents.with_raw_response.handle_rpc( + agent_id="", + method="event/send", + params={}, + ) + + @pytest.mark.skip() + @parametrize + def test_method_handle_rpc_overload_2(self, client: AgentexSDK) -> None: + agent = client.agents.handle_rpc( agent_id="agent_id", method="event/send", params={}, ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(JSONLDecoder[object], agent, path=["response"]) @pytest.mark.skip() @parametrize - def test_method_rpc_with_all_params(self, client: AgentexSDK) -> None: - agent = client.agents.rpc( + def test_method_handle_rpc_with_all_params_overload_2(self, client: AgentexSDK) -> None: + agent = client.agents.handle_rpc( agent_id="agent_id", method="event/send", params={ @@ -218,12 +229,12 @@ def test_method_rpc_with_all_params(self, client: AgentexSDK) -> None: id=0, jsonrpc="2.0", ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(JSONLDecoder[object], agent, path=["response"]) @pytest.mark.skip() @parametrize - def test_raw_response_rpc(self, client: AgentexSDK) -> None: - response = client.agents.with_raw_response.rpc( + def test_raw_response_handle_rpc_overload_2(self, client: AgentexSDK) -> None: + response = client.agents.with_raw_response.handle_rpc( agent_id="agent_id", method="event/send", params={}, @@ -232,12 +243,12 @@ def test_raw_response_rpc(self, client: AgentexSDK) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(JSONLDecoder[object], agent, path=["response"]) @pytest.mark.skip() @parametrize - def test_streaming_response_rpc(self, client: AgentexSDK) -> None: - with client.agents.with_streaming_response.rpc( + def test_streaming_response_handle_rpc_overload_2(self, client: AgentexSDK) -> None: + with client.agents.with_streaming_response.handle_rpc( agent_id="agent_id", method="event/send", params={}, @@ -246,20 +257,75 @@ def test_streaming_response_rpc(self, client: AgentexSDK) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(JSONLDecoder[object], agent, path=["response"]) assert cast(Any, response.is_closed) is True @pytest.mark.skip() @parametrize - def test_path_params_rpc(self, client: AgentexSDK) -> None: + def test_path_params_handle_rpc_overload_2(self, client: AgentexSDK) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): - client.agents.with_raw_response.rpc( + client.agents.with_raw_response.handle_rpc( agent_id="", method="event/send", params={}, ) + @pytest.mark.skip() + @parametrize + def test_method_register(self, client: AgentexSDK) -> None: + agent = client.agents.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_register_with_all_params(self, client: AgentexSDK) -> None: + agent = client.agents.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + agent_id="agent_id", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_register(self, client: AgentexSDK) -> None: + response = client.agents.with_raw_response.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_register(self, client: AgentexSDK) -> None: + with client.agents.with_streaming_response.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + class TestAsyncAgents: parametrize = pytest.mark.parametrize( @@ -388,73 +454,83 @@ async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_register(self, async_client: AsyncAgentexSDK) -> None: - agent = await async_client.agents.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", + async def test_method_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.handle_rpc( + agent_id="agent_id", + method="event/send", + params={}, ) - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) @pytest.mark.skip() @parametrize - async def test_method_register_with_all_params(self, async_client: AsyncAgentexSDK) -> None: - agent = await async_client.agents.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", + async def test_method_handle_rpc_with_all_params_overload_1(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.handle_rpc( agent_id="agent_id", + method="event/send", + params={ + "name": "name", + "params": {"foo": "bar"}, + }, + id=0, + jsonrpc="2.0", ) - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) @pytest.mark.skip() @parametrize - async def test_raw_response_register(self, async_client: AsyncAgentexSDK) -> None: - response = await async_client.agents.with_raw_response.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", + async def test_raw_response_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.agents.with_raw_response.handle_rpc( + agent_id="agent_id", + method="event/send", + params={}, ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) @pytest.mark.skip() @parametrize - async def test_streaming_response_register(self, async_client: AsyncAgentexSDK) -> None: - async with async_client.agents.with_streaming_response.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", + async def test_streaming_response_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.agents.with_streaming_response.handle_rpc( + agent_id="agent_id", + method="event/send", + params={}, ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) assert cast(Any, response.is_closed) is True @pytest.mark.skip() @parametrize - async def test_method_rpc(self, async_client: AsyncAgentexSDK) -> None: - agent = await async_client.agents.rpc( + async def test_path_params_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): + await async_client.agents.with_raw_response.handle_rpc( + agent_id="", + method="event/send", + params={}, + ) + + @pytest.mark.skip() + @parametrize + async def test_method_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.handle_rpc( agent_id="agent_id", method="event/send", params={}, ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) @pytest.mark.skip() @parametrize - async def test_method_rpc_with_all_params(self, async_client: AsyncAgentexSDK) -> None: - agent = await async_client.agents.rpc( + async def test_method_handle_rpc_with_all_params_overload_2(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.handle_rpc( agent_id="agent_id", method="event/send", params={ @@ -464,12 +540,12 @@ async def test_method_rpc_with_all_params(self, async_client: AsyncAgentexSDK) - id=0, jsonrpc="2.0", ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) @pytest.mark.skip() @parametrize - async def test_raw_response_rpc(self, async_client: AsyncAgentexSDK) -> None: - response = await async_client.agents.with_raw_response.rpc( + async def test_raw_response_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.agents.with_raw_response.handle_rpc( agent_id="agent_id", method="event/send", params={}, @@ -478,12 +554,12 @@ async def test_raw_response_rpc(self, async_client: AsyncAgentexSDK) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) @pytest.mark.skip() @parametrize - async def test_streaming_response_rpc(self, async_client: AsyncAgentexSDK) -> None: - async with async_client.agents.with_streaming_response.rpc( + async def test_streaming_response_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.agents.with_streaming_response.handle_rpc( agent_id="agent_id", method="event/send", params={}, @@ -492,16 +568,71 @@ async def test_streaming_response_rpc(self, async_client: AsyncAgentexSDK) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) assert cast(Any, response.is_closed) is True @pytest.mark.skip() @parametrize - async def test_path_params_rpc(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): - await async_client.agents.with_raw_response.rpc( + await async_client.agents.with_raw_response.handle_rpc( agent_id="", method="event/send", params={}, ) + + @pytest.mark.skip() + @parametrize + async def test_method_register(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_register_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + agent_id="agent_id", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_register(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.agents.with_raw_response.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = await response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_register(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.agents.with_streaming_response.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = await response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/decoders/test_jsonl.py b/tests/decoders/test_jsonl.py new file mode 100644 index 00000000..26f32b3d --- /dev/null +++ b/tests/decoders/test_jsonl.py @@ -0,0 +1,88 @@ +from __future__ import annotations + +from typing import Any, Iterator, AsyncIterator +from typing_extensions import TypeVar + +import httpx +import pytest + +from agentex_sdk._decoders.jsonl import JSONLDecoder, AsyncJSONLDecoder + +_T = TypeVar("_T") + + +@pytest.mark.asyncio +@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) +async def test_basic(sync: bool) -> None: + def body() -> Iterator[bytes]: + yield b'{"foo":true}\n' + yield b'{"bar":false}\n' + + iterator = make_jsonl_iterator( + content=body(), + sync=sync, + line_type=object, + ) + + assert await iter_next(iterator) == {"foo": True} + assert await iter_next(iterator) == {"bar": False} + + await assert_empty_iter(iterator) + + +@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) +async def test_new_lines_in_json( + sync: bool, +) -> None: + def body() -> Iterator[bytes]: + yield b'{"content":"Hello, world!\\nHow are you doing?"}' + + iterator = make_jsonl_iterator(content=body(), sync=sync, line_type=object) + + assert await iter_next(iterator) == {"content": "Hello, world!\nHow are you doing?"} + + +@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) +async def test_multi_byte_character_multiple_chunks( + sync: bool, +) -> None: + def body() -> Iterator[bytes]: + yield b'{"content":"' + # bytes taken from the string 'известни' and arbitrarily split + # so that some multi-byte characters span multiple chunks + yield b"\xd0" + yield b"\xb8\xd0\xb7\xd0" + yield b"\xb2\xd0\xb5\xd1\x81\xd1\x82\xd0\xbd\xd0\xb8" + yield b'"}\n' + + iterator = make_jsonl_iterator(content=body(), sync=sync, line_type=object) + + assert await iter_next(iterator) == {"content": "известни"} + + +async def to_aiter(iter: Iterator[bytes]) -> AsyncIterator[bytes]: + for chunk in iter: + yield chunk + + +async def iter_next(iter: Iterator[_T] | AsyncIterator[_T]) -> _T: + if isinstance(iter, AsyncIterator): + return await iter.__anext__() + return next(iter) + + +async def assert_empty_iter(decoder: JSONLDecoder[Any] | AsyncJSONLDecoder[Any]) -> None: + with pytest.raises((StopAsyncIteration, RuntimeError)): + await iter_next(decoder) + + +def make_jsonl_iterator( + content: Iterator[bytes], + *, + sync: bool, + line_type: type[_T], +) -> JSONLDecoder[_T] | AsyncJSONLDecoder[_T]: + if sync: + return JSONLDecoder(line_type=line_type, raw_iterator=content, http_response=httpx.Response(200)) + + return AsyncJSONLDecoder(line_type=line_type, raw_iterator=to_aiter(content), http_response=httpx.Response(200)) From 5647c93869804dc7d51716a496c00e96e5c5bc43 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 16 Jul 2025 23:39:29 +0000 Subject: [PATCH 0005/1108] feat(api): update via SDK Studio --- .stats.yml | 4 +- api.md | 1 + src/agentex_sdk/resources/agents/name.py | 210 ++++++++++++++ src/agentex_sdk/types/agents/__init__.py | 2 + .../types/agents/name_handle_rpc_params.py | 97 +++++++ tests/api_resources/agents/test_name.py | 261 ++++++++++++++++++ 6 files changed, 573 insertions(+), 2 deletions(-) create mode 100644 src/agentex_sdk/types/agents/name_handle_rpc_params.py diff --git a/.stats.yml b/.stats.yml index a41c3504..e55370b5 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 36 +configured_endpoints: 37 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-7a38e3675674c19ea4fa2ca0cfef23aa1d96dbdb29ca3ba4194b0e858d0a4ee0.yml openapi_spec_hash: 55a7eae5bc606e4ac91841d7e675723e -config_hash: bc7843ae93d8ed57135ad547127ba0f5 +config_hash: c2b03f64bec1a902eee83c801e540718 diff --git a/api.md b/api.md index 0fab860f..9ca9b558 100644 --- a/api.md +++ b/api.md @@ -32,6 +32,7 @@ Methods: - client.agents.name.retrieve(agent_name) -> Agent - client.agents.name.delete(agent_name) -> Agent +- client.agents.name.handle_rpc(agent_name, \*\*params) -> JSONLDecoder[object] # Tasks diff --git a/src/agentex_sdk/resources/agents/name.py b/src/agentex_sdk/resources/agents/name.py index 167983b1..4b0b0b89 100644 --- a/src/agentex_sdk/resources/agents/name.py +++ b/src/agentex_sdk/resources/agents/name.py @@ -2,9 +2,13 @@ from __future__ import annotations +from typing import Union +from typing_extensions import Literal, overload + import httpx from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._utils import required_args, maybe_transform, async_maybe_transform from ..._compat import cached_property from ..._resource import SyncAPIResource, AsyncAPIResource from ..._response import ( @@ -15,6 +19,8 @@ ) from ...types.agent import Agent from ..._base_client import make_request_options +from ...types.agents import name_handle_rpc_params +from ..._decoders.jsonl import JSONLDecoder, AsyncJSONLDecoder __all__ = ["NameResource", "AsyncNameResource"] @@ -105,6 +111,102 @@ def delete( cast_to=Agent, ) + @overload + def handle_rpc( + self, + agent_name: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: name_handle_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> JSONLDecoder[object]: + """ + Handle JSON-RPC requests for an agent by its unique name. + + Args: + 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 handle_rpc( + self, + agent_name: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: name_handle_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> JSONLDecoder[object]: + """ + Handle JSON-RPC requests for an agent by its unique name. + + Args: + 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 + """ + ... + + @required_args(["method", "params"]) + def handle_rpc( + self, + agent_name: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: name_handle_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> JSONLDecoder[object] | JSONLDecoder[object]: + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return self._post( + f"/agents/name/{agent_name}/rpc", + body=maybe_transform( + { + "method": method, + "params": params, + "id": id, + "jsonrpc": jsonrpc, + }, + name_handle_rpc_params.NameHandleRpcParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=JSONLDecoder[object], + stream=todo_unsupported or False, + ) + class AsyncNameResource(AsyncAPIResource): @cached_property @@ -192,6 +294,102 @@ async def delete( cast_to=Agent, ) + @overload + async def handle_rpc( + self, + agent_name: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: name_handle_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> AsyncJSONLDecoder[object]: + """ + Handle JSON-RPC requests for an agent by its unique name. + + Args: + 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 handle_rpc( + self, + agent_name: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: name_handle_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> AsyncJSONLDecoder[object]: + """ + Handle JSON-RPC requests for an agent by its unique name. + + Args: + 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 + """ + ... + + @required_args(["method", "params"]) + async def handle_rpc( + self, + agent_name: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: name_handle_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> AsyncJSONLDecoder[object] | AsyncJSONLDecoder[object]: + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return await self._post( + f"/agents/name/{agent_name}/rpc", + body=await async_maybe_transform( + { + "method": method, + "params": params, + "id": id, + "jsonrpc": jsonrpc, + }, + name_handle_rpc_params.NameHandleRpcParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AsyncJSONLDecoder[object], + stream=todo_unsupported or False, + ) + class NameResourceWithRawResponse: def __init__(self, name: NameResource) -> None: @@ -203,6 +401,9 @@ def __init__(self, name: NameResource) -> None: self.delete = to_raw_response_wrapper( name.delete, ) + self.handle_rpc = to_raw_response_wrapper( + name.handle_rpc, + ) class AsyncNameResourceWithRawResponse: @@ -215,6 +416,9 @@ def __init__(self, name: AsyncNameResource) -> None: self.delete = async_to_raw_response_wrapper( name.delete, ) + self.handle_rpc = async_to_raw_response_wrapper( + name.handle_rpc, + ) class NameResourceWithStreamingResponse: @@ -227,6 +431,9 @@ def __init__(self, name: NameResource) -> None: self.delete = to_streamed_response_wrapper( name.delete, ) + self.handle_rpc = to_streamed_response_wrapper( + name.handle_rpc, + ) class AsyncNameResourceWithStreamingResponse: @@ -239,3 +446,6 @@ def __init__(self, name: AsyncNameResource) -> None: self.delete = async_to_streamed_response_wrapper( name.delete, ) + self.handle_rpc = async_to_streamed_response_wrapper( + name.handle_rpc, + ) diff --git a/src/agentex_sdk/types/agents/__init__.py b/src/agentex_sdk/types/agents/__init__.py index f8ee8b14..c1760c0e 100644 --- a/src/agentex_sdk/types/agents/__init__.py +++ b/src/agentex_sdk/types/agents/__init__.py @@ -1,3 +1,5 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. from __future__ import annotations + +from .name_handle_rpc_params import NameHandleRpcParams as NameHandleRpcParams diff --git a/src/agentex_sdk/types/agents/name_handle_rpc_params.py b/src/agentex_sdk/types/agents/name_handle_rpc_params.py new file mode 100644 index 00000000..f53c09bf --- /dev/null +++ b/src/agentex_sdk/types/agents/name_handle_rpc_params.py @@ -0,0 +1,97 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict, Union, Optional +from typing_extensions import Literal, Required, TypeAlias, TypedDict + +from ..data_content_param import DataContentParam +from ..text_content_param import TextContentParam +from ..tool_request_content_param import ToolRequestContentParam +from ..tool_response_content_param import ToolResponseContentParam + +__all__ = [ + "NameHandleRpcParamsBase", + "Params", + "ParamsCreateTaskRequest", + "ParamsCancelTaskRequest", + "ParamsSendMessageRequest", + "ParamsSendMessageRequestContent", + "ParamsSendEventRequest", + "ParamsSendEventRequestContent", + "NameHandleRpcParamsNonStreaming", +] + + +class NameHandleRpcParamsBase(TypedDict, total=False): + method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] + + params: Required[Params] + + id: Union[int, str, None] + + jsonrpc: Literal["2.0"] + + +class ParamsCreateTaskRequest(TypedDict, total=False): + name: Optional[str] + """The name of the task to create""" + + params: Optional[Dict[str, object]] + """The parameters for the task""" + + +class ParamsCancelTaskRequest(TypedDict, total=False): + task_id: Optional[str] + """The ID of the task to cancel. Either this or task_name must be provided.""" + + task_name: Optional[str] + """The name of the task to cancel. Either this or task_id must be provided.""" + + +ParamsSendMessageRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendMessageRequest(TypedDict, total=False): + content: Required[ParamsSendMessageRequestContent] + """The message that was sent to the agent""" + + stream: bool + """Whether to stream the response message back to the client""" + + task_id: Optional[str] + """The ID of the task that the message was sent to""" + + +ParamsSendEventRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendEventRequest(TypedDict, total=False): + content: Optional[ParamsSendEventRequestContent] + """The content to send to the event""" + + task_id: Optional[str] + """The ID of the task that the event was sent to""" + + task_name: Optional[str] + """The name of the task that the event was sent to""" + + +Params: TypeAlias = Union[ + ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest +] + + +class NameHandleRpcParamsNonStreaming(NameHandleRpcParamsBase, total=False): + pass + + +class NameHandleRpcParamsNonStreaming(NameHandleRpcParamsBase, total=False): + pass + + +NameHandleRpcParams = Union[NameHandleRpcParamsNonStreaming, NameHandleRpcParamsNonStreaming] diff --git a/tests/api_resources/agents/test_name.py b/tests/api_resources/agents/test_name.py index c3df381b..7ee6edc1 100644 --- a/tests/api_resources/agents/test_name.py +++ b/tests/api_resources/agents/test_name.py @@ -10,6 +10,7 @@ from agentex_sdk import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type from agentex_sdk.types import Agent +from agentex_sdk._decoders.jsonl import JSONLDecoder, AsyncJSONLDecoder base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -101,6 +102,136 @@ def test_path_params_delete(self, client: AgentexSDK) -> None: "", ) + @pytest.mark.skip() + @parametrize + def test_method_handle_rpc_overload_1(self, client: AgentexSDK) -> None: + name = client.agents.name.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + assert_matches_type(JSONLDecoder[object], name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_handle_rpc_with_all_params_overload_1(self, client: AgentexSDK) -> None: + name = client.agents.name.handle_rpc( + agent_name="agent_name", + method="event/send", + params={ + "name": "name", + "params": {"foo": "bar"}, + }, + id=0, + jsonrpc="2.0", + ) + assert_matches_type(JSONLDecoder[object], name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_handle_rpc_overload_1(self, client: AgentexSDK) -> None: + response = client.agents.name.with_raw_response.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = response.parse() + assert_matches_type(JSONLDecoder[object], name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_handle_rpc_overload_1(self, client: AgentexSDK) -> None: + with client.agents.name.with_streaming_response.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = response.parse() + assert_matches_type(JSONLDecoder[object], name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_handle_rpc_overload_1(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + client.agents.name.with_raw_response.handle_rpc( + agent_name="", + method="event/send", + params={}, + ) + + @pytest.mark.skip() + @parametrize + def test_method_handle_rpc_overload_2(self, client: AgentexSDK) -> None: + name = client.agents.name.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + assert_matches_type(JSONLDecoder[object], name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_handle_rpc_with_all_params_overload_2(self, client: AgentexSDK) -> None: + name = client.agents.name.handle_rpc( + agent_name="agent_name", + method="event/send", + params={ + "name": "name", + "params": {"foo": "bar"}, + }, + id=0, + jsonrpc="2.0", + ) + assert_matches_type(JSONLDecoder[object], name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_handle_rpc_overload_2(self, client: AgentexSDK) -> None: + response = client.agents.name.with_raw_response.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = response.parse() + assert_matches_type(JSONLDecoder[object], name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_handle_rpc_overload_2(self, client: AgentexSDK) -> None: + with client.agents.name.with_streaming_response.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = response.parse() + assert_matches_type(JSONLDecoder[object], name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_handle_rpc_overload_2(self, client: AgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + client.agents.name.with_raw_response.handle_rpc( + agent_name="", + method="event/send", + params={}, + ) + class TestAsyncName: parametrize = pytest.mark.parametrize( @@ -190,3 +321,133 @@ async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: await async_client.agents.name.with_raw_response.delete( "", ) + + @pytest.mark.skip() + @parametrize + async def test_method_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: + name = await async_client.agents.name.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_handle_rpc_with_all_params_overload_1(self, async_client: AsyncAgentexSDK) -> None: + name = await async_client.agents.name.handle_rpc( + agent_name="agent_name", + method="event/send", + params={ + "name": "name", + "params": {"foo": "bar"}, + }, + id=0, + jsonrpc="2.0", + ) + assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.agents.name.with_raw_response.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = await response.parse() + assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.agents.name.with_streaming_response.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = await response.parse() + assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + await async_client.agents.name.with_raw_response.handle_rpc( + agent_name="", + method="event/send", + params={}, + ) + + @pytest.mark.skip() + @parametrize + async def test_method_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: + name = await async_client.agents.name.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_handle_rpc_with_all_params_overload_2(self, async_client: AsyncAgentexSDK) -> None: + name = await async_client.agents.name.handle_rpc( + agent_name="agent_name", + method="event/send", + params={ + "name": "name", + "params": {"foo": "bar"}, + }, + id=0, + jsonrpc="2.0", + ) + assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.agents.name.with_raw_response.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = await response.parse() + assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.agents.name.with_streaming_response.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = await response.parse() + assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + await async_client.agents.name.with_raw_response.handle_rpc( + agent_name="", + method="event/send", + params={}, + ) From 3c7056b0fd56647f8f11a5f50ab2ff6c2e955e40 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 16 Jul 2025 23:44:31 +0000 Subject: [PATCH 0006/1108] feat(api): update via SDK Studio --- .stats.yml | 2 +- api.md | 4 +- src/agentex_sdk/_decoders/jsonl.py | 123 ------- src/agentex_sdk/_response.py | 22 -- src/agentex_sdk/resources/agents/agents.py | 283 ++++++----------- src/agentex_sdk/resources/agents/name.py | 143 ++------- src/agentex_sdk/types/__init__.py | 2 +- ...ndle_rpc_params.py => agent_rpc_params.py} | 16 +- src/agentex_sdk/types/agents/__init__.py | 2 +- ...andle_rpc_params.py => name_rpc_params.py} | 16 +- tests/api_resources/agents/test_name.py | 187 ++--------- tests/api_resources/test_agents.py | 299 +++++------------- tests/decoders/test_jsonl.py | 88 ------ 13 files changed, 233 insertions(+), 954 deletions(-) delete mode 100644 src/agentex_sdk/_decoders/jsonl.py rename src/agentex_sdk/types/{agent_handle_rpc_params.py => agent_rpc_params.py} (85%) rename src/agentex_sdk/types/agents/{name_handle_rpc_params.py => name_rpc_params.py} (86%) delete mode 100644 tests/decoders/test_jsonl.py diff --git a/.stats.yml b/.stats.yml index e55370b5..cf8fb92d 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 37 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-7a38e3675674c19ea4fa2ca0cfef23aa1d96dbdb29ca3ba4194b0e858d0a4ee0.yml openapi_spec_hash: 55a7eae5bc606e4ac91841d7e675723e -config_hash: c2b03f64bec1a902eee83c801e540718 +config_hash: fbda9c84b0140c8ae711ef5e6aaf1f31 diff --git a/api.md b/api.md index 9ca9b558..2583c643 100644 --- a/api.md +++ b/api.md @@ -23,8 +23,8 @@ Methods: - client.agents.retrieve(agent_id) -> Agent - client.agents.list(\*\*params) -> AgentListResponse - client.agents.delete(agent_id) -> Agent -- client.agents.handle_rpc(agent_id, \*\*params) -> JSONLDecoder[object] - client.agents.register(\*\*params) -> Agent +- client.agents.rpc(agent_id, \*\*params) -> object ## Name @@ -32,7 +32,7 @@ Methods: - client.agents.name.retrieve(agent_name) -> Agent - client.agents.name.delete(agent_name) -> Agent -- client.agents.name.handle_rpc(agent_name, \*\*params) -> JSONLDecoder[object] +- client.agents.name.rpc(agent_name, \*\*params) -> object # Tasks diff --git a/src/agentex_sdk/_decoders/jsonl.py b/src/agentex_sdk/_decoders/jsonl.py deleted file mode 100644 index ac5ac74f..00000000 --- a/src/agentex_sdk/_decoders/jsonl.py +++ /dev/null @@ -1,123 +0,0 @@ -from __future__ import annotations - -import json -from typing_extensions import Generic, TypeVar, Iterator, AsyncIterator - -import httpx - -from .._models import construct_type_unchecked - -_T = TypeVar("_T") - - -class JSONLDecoder(Generic[_T]): - """A decoder for [JSON Lines](https://jsonlines.org) format. - - This class provides an iterator over a byte-iterator that parses each JSON Line - into a given type. - """ - - http_response: httpx.Response - """The HTTP response this decoder was constructed from""" - - def __init__( - self, - *, - raw_iterator: Iterator[bytes], - line_type: type[_T], - http_response: httpx.Response, - ) -> None: - super().__init__() - self.http_response = http_response - self._raw_iterator = raw_iterator - self._line_type = line_type - self._iterator = self.__decode__() - - def close(self) -> None: - """Close the response body stream. - - This is called automatically if you consume the entire stream. - """ - self.http_response.close() - - def __decode__(self) -> Iterator[_T]: - buf = b"" - for chunk in self._raw_iterator: - for line in chunk.splitlines(keepends=True): - buf += line - if buf.endswith((b"\r", b"\n", b"\r\n")): - yield construct_type_unchecked( - value=json.loads(buf), - type_=self._line_type, - ) - buf = b"" - - # flush - if buf: - yield construct_type_unchecked( - value=json.loads(buf), - type_=self._line_type, - ) - - def __next__(self) -> _T: - return self._iterator.__next__() - - def __iter__(self) -> Iterator[_T]: - for item in self._iterator: - yield item - - -class AsyncJSONLDecoder(Generic[_T]): - """A decoder for [JSON Lines](https://jsonlines.org) format. - - This class provides an async iterator over a byte-iterator that parses each JSON Line - into a given type. - """ - - http_response: httpx.Response - - def __init__( - self, - *, - raw_iterator: AsyncIterator[bytes], - line_type: type[_T], - http_response: httpx.Response, - ) -> None: - super().__init__() - self.http_response = http_response - self._raw_iterator = raw_iterator - self._line_type = line_type - self._iterator = self.__decode__() - - async def close(self) -> None: - """Close the response body stream. - - This is called automatically if you consume the entire stream. - """ - await self.http_response.aclose() - - async def __decode__(self) -> AsyncIterator[_T]: - buf = b"" - async for chunk in self._raw_iterator: - for line in chunk.splitlines(keepends=True): - buf += line - if buf.endswith((b"\r", b"\n", b"\r\n")): - yield construct_type_unchecked( - value=json.loads(buf), - type_=self._line_type, - ) - buf = b"" - - # flush - if buf: - yield construct_type_unchecked( - value=json.loads(buf), - type_=self._line_type, - ) - - async def __anext__(self) -> _T: - return await self._iterator.__anext__() - - async def __aiter__(self) -> AsyncIterator[_T]: - async for item in self._iterator: - yield item diff --git a/src/agentex_sdk/_response.py b/src/agentex_sdk/_response.py index 3caafa10..d8115d31 100644 --- a/src/agentex_sdk/_response.py +++ b/src/agentex_sdk/_response.py @@ -30,7 +30,6 @@ from ._constants import RAW_RESPONSE_HEADER, OVERRIDE_CAST_TO_HEADER from ._streaming import Stream, AsyncStream, is_stream_class_type, extract_stream_chunk_type from ._exceptions import AgentexSDKError, APIResponseValidationError -from ._decoders.jsonl import JSONLDecoder, AsyncJSONLDecoder if TYPE_CHECKING: from ._models import FinalRequestOptions @@ -139,27 +138,6 @@ def _parse(self, *, to: type[_T] | None = None) -> R | _T: origin = get_origin(cast_to) or cast_to - if inspect.isclass(origin): - if issubclass(cast(Any, origin), JSONLDecoder): - return cast( - R, - cast("type[JSONLDecoder[Any]]", cast_to)( - raw_iterator=self.http_response.iter_bytes(chunk_size=64), - line_type=extract_type_arg(cast_to, 0), - http_response=self.http_response, - ), - ) - - if issubclass(cast(Any, origin), AsyncJSONLDecoder): - return cast( - R, - cast("type[AsyncJSONLDecoder[Any]]", cast_to)( - raw_iterator=self.http_response.aiter_bytes(chunk_size=64), - line_type=extract_type_arg(cast_to, 0), - http_response=self.http_response, - ), - ) - if self._is_sse_stream: if to: if not is_stream_class_type(to): diff --git a/src/agentex_sdk/resources/agents/agents.py b/src/agentex_sdk/resources/agents/agents.py index 0f2f45d2..17642e0b 100644 --- a/src/agentex_sdk/resources/agents/agents.py +++ b/src/agentex_sdk/resources/agents/agents.py @@ -3,7 +3,7 @@ from __future__ import annotations from typing import Union, Optional -from typing_extensions import Literal, overload +from typing_extensions import Literal import httpx @@ -15,9 +15,9 @@ NameResourceWithStreamingResponse, AsyncNameResourceWithStreamingResponse, ) -from ...types import AcpType, agent_list_params, agent_register_params, agent_handle_rpc_params +from ...types import AcpType, agent_rpc_params, agent_list_params, agent_register_params from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from ..._utils import required_args, maybe_transform, async_maybe_transform +from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property from ..._resource import SyncAPIResource, AsyncAPIResource from ..._response import ( @@ -29,7 +29,6 @@ from ...types.agent import Agent from ..._base_client import make_request_options from ...types.acp_type import AcpType -from ..._decoders.jsonl import JSONLDecoder, AsyncJSONLDecoder from ...types.agent_list_response import AgentListResponse __all__ = ["AgentsResource", "AsyncAgentsResource"] @@ -162,56 +161,35 @@ def delete( cast_to=Agent, ) - @overload - def handle_rpc( + def register( self, - agent_id: str, *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_handle_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + acp_type: AcpType, + acp_url: str, + description: str, + name: str, + agent_id: Optional[str] | NotGiven = NOT_GIVEN, # 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, - ) -> JSONLDecoder[object]: + ) -> Agent: """ - Handle JSON-RPC requests for an agent by its unique ID. + Register a new agent or update an existing one. Args: - extra_headers: Send extra headers + acp_type: The type of ACP to use for the agent. - extra_query: Add additional query parameters to the request + acp_url: The URL of the ACP server for the agent. - extra_body: Add additional JSON properties to the request + description: The description of the agent. - timeout: Override the client-level default timeout for this request, in seconds - """ - ... + name: The unique name of the agent. - @overload - def handle_rpc( - self, - agent_id: str, - *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_handle_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, - # 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, - ) -> JSONLDecoder[object]: - """ - Handle JSON-RPC requests for an agent by its unique ID. + agent_id: Optional agent ID if the agent already exists and needs to be updated. - Args: extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -220,73 +198,43 @@ def handle_rpc( timeout: Override the client-level default timeout for this request, in seconds """ - ... - - @required_args(["method", "params"]) - def handle_rpc( - self, - agent_id: str, - *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_handle_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, - # 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, - ) -> JSONLDecoder[object] | JSONLDecoder[object]: - if not agent_id: - raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") return self._post( - f"/agents/{agent_id}/rpc", + "/agents/register", body=maybe_transform( { - "method": method, - "params": params, - "id": id, - "jsonrpc": jsonrpc, + "acp_type": acp_type, + "acp_url": acp_url, + "description": description, + "name": name, + "agent_id": agent_id, }, - agent_handle_rpc_params.AgentHandleRpcParams, + agent_register_params.AgentRegisterParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=JSONLDecoder[object], - stream=todo_unsupported or False, + cast_to=Agent, ) - def register( + def rpc( self, + agent_id: str, *, - acp_type: AcpType, - acp_url: str, - description: str, - name: str, - agent_id: Optional[str] | NotGiven = NOT_GIVEN, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: agent_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # 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, - ) -> Agent: + ) -> object: """ - Register a new agent or update an existing one. + Handle JSON-RPC requests for an agent by its unique ID. Args: - acp_type: The type of ACP to use for the agent. - - acp_url: The URL of the ACP server for the agent. - - description: The description of the agent. - - name: The unique name of the agent. - - agent_id: Optional agent ID if the agent already exists and needs to be updated. - extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -295,22 +243,23 @@ def register( timeout: Override the client-level default timeout for this request, in seconds """ + if not agent_id: + raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") return self._post( - "/agents/register", + f"/agents/{agent_id}/rpc", body=maybe_transform( { - "acp_type": acp_type, - "acp_url": acp_url, - "description": description, - "name": name, - "agent_id": agent_id, + "method": method, + "params": params, + "id": id, + "jsonrpc": jsonrpc, }, - agent_register_params.AgentRegisterParams, + agent_rpc_params.AgentRpcParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Agent, + cast_to=object, ) @@ -441,56 +390,35 @@ async def delete( cast_to=Agent, ) - @overload - async def handle_rpc( + async def register( self, - agent_id: str, *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_handle_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + acp_type: AcpType, + acp_url: str, + description: str, + name: str, + agent_id: Optional[str] | NotGiven = NOT_GIVEN, # 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, - ) -> AsyncJSONLDecoder[object]: + ) -> Agent: """ - Handle JSON-RPC requests for an agent by its unique ID. + Register a new agent or update an existing one. Args: - extra_headers: Send extra headers + acp_type: The type of ACP to use for the agent. - extra_query: Add additional query parameters to the request + acp_url: The URL of the ACP server for the agent. - extra_body: Add additional JSON properties to the request + description: The description of the agent. - timeout: Override the client-level default timeout for this request, in seconds - """ - ... + name: The unique name of the agent. - @overload - async def handle_rpc( - self, - agent_id: str, - *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_handle_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, - # 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, - ) -> AsyncJSONLDecoder[object]: - """ - Handle JSON-RPC requests for an agent by its unique ID. + agent_id: Optional agent ID if the agent already exists and needs to be updated. - Args: extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -499,73 +427,43 @@ async def handle_rpc( timeout: Override the client-level default timeout for this request, in seconds """ - ... - - @required_args(["method", "params"]) - async def handle_rpc( - self, - agent_id: str, - *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_handle_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, - # 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, - ) -> AsyncJSONLDecoder[object] | AsyncJSONLDecoder[object]: - if not agent_id: - raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") return await self._post( - f"/agents/{agent_id}/rpc", + "/agents/register", body=await async_maybe_transform( { - "method": method, - "params": params, - "id": id, - "jsonrpc": jsonrpc, + "acp_type": acp_type, + "acp_url": acp_url, + "description": description, + "name": name, + "agent_id": agent_id, }, - agent_handle_rpc_params.AgentHandleRpcParams, + agent_register_params.AgentRegisterParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AsyncJSONLDecoder[object], - stream=todo_unsupported or False, + cast_to=Agent, ) - async def register( + async def rpc( self, + agent_id: str, *, - acp_type: AcpType, - acp_url: str, - description: str, - name: str, - agent_id: Optional[str] | NotGiven = NOT_GIVEN, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: agent_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # 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, - ) -> Agent: + ) -> object: """ - Register a new agent or update an existing one. + Handle JSON-RPC requests for an agent by its unique ID. Args: - acp_type: The type of ACP to use for the agent. - - acp_url: The URL of the ACP server for the agent. - - description: The description of the agent. - - name: The unique name of the agent. - - agent_id: Optional agent ID if the agent already exists and needs to be updated. - extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -574,22 +472,23 @@ async def register( timeout: Override the client-level default timeout for this request, in seconds """ + if not agent_id: + raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") return await self._post( - "/agents/register", + f"/agents/{agent_id}/rpc", body=await async_maybe_transform( { - "acp_type": acp_type, - "acp_url": acp_url, - "description": description, - "name": name, - "agent_id": agent_id, + "method": method, + "params": params, + "id": id, + "jsonrpc": jsonrpc, }, - agent_register_params.AgentRegisterParams, + agent_rpc_params.AgentRpcParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Agent, + cast_to=object, ) @@ -606,12 +505,12 @@ def __init__(self, agents: AgentsResource) -> None: self.delete = to_raw_response_wrapper( agents.delete, ) - self.handle_rpc = to_raw_response_wrapper( - agents.handle_rpc, - ) self.register = to_raw_response_wrapper( agents.register, ) + self.rpc = to_raw_response_wrapper( + agents.rpc, + ) @cached_property def name(self) -> NameResourceWithRawResponse: @@ -631,12 +530,12 @@ def __init__(self, agents: AsyncAgentsResource) -> None: self.delete = async_to_raw_response_wrapper( agents.delete, ) - self.handle_rpc = async_to_raw_response_wrapper( - agents.handle_rpc, - ) self.register = async_to_raw_response_wrapper( agents.register, ) + self.rpc = async_to_raw_response_wrapper( + agents.rpc, + ) @cached_property def name(self) -> AsyncNameResourceWithRawResponse: @@ -656,12 +555,12 @@ def __init__(self, agents: AgentsResource) -> None: self.delete = to_streamed_response_wrapper( agents.delete, ) - self.handle_rpc = to_streamed_response_wrapper( - agents.handle_rpc, - ) self.register = to_streamed_response_wrapper( agents.register, ) + self.rpc = to_streamed_response_wrapper( + agents.rpc, + ) @cached_property def name(self) -> NameResourceWithStreamingResponse: @@ -681,12 +580,12 @@ def __init__(self, agents: AsyncAgentsResource) -> None: self.delete = async_to_streamed_response_wrapper( agents.delete, ) - self.handle_rpc = async_to_streamed_response_wrapper( - agents.handle_rpc, - ) self.register = async_to_streamed_response_wrapper( agents.register, ) + self.rpc = async_to_streamed_response_wrapper( + agents.rpc, + ) @cached_property def name(self) -> AsyncNameResourceWithStreamingResponse: diff --git a/src/agentex_sdk/resources/agents/name.py b/src/agentex_sdk/resources/agents/name.py index 4b0b0b89..a386d7fd 100644 --- a/src/agentex_sdk/resources/agents/name.py +++ b/src/agentex_sdk/resources/agents/name.py @@ -3,12 +3,12 @@ from __future__ import annotations from typing import Union -from typing_extensions import Literal, overload +from typing_extensions import Literal import httpx from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from ..._utils import required_args, maybe_transform, async_maybe_transform +from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property from ..._resource import SyncAPIResource, AsyncAPIResource from ..._response import ( @@ -19,8 +19,7 @@ ) from ...types.agent import Agent from ..._base_client import make_request_options -from ...types.agents import name_handle_rpc_params -from ..._decoders.jsonl import JSONLDecoder, AsyncJSONLDecoder +from ...types.agents import name_rpc_params __all__ = ["NameResource", "AsyncNameResource"] @@ -111,13 +110,12 @@ def delete( cast_to=Agent, ) - @overload - def handle_rpc( + def rpc( self, agent_name: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: name_handle_rpc_params.Params, + params: name_rpc_params.Params, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -126,7 +124,7 @@ def handle_rpc( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> JSONLDecoder[object]: + ) -> object: """ Handle JSON-RPC requests for an agent by its unique name. @@ -139,54 +137,6 @@ def handle_rpc( timeout: Override the client-level default timeout for this request, in seconds """ - ... - - @overload - def handle_rpc( - self, - agent_name: str, - *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: name_handle_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, - # 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, - ) -> JSONLDecoder[object]: - """ - Handle JSON-RPC requests for an agent by its unique name. - - Args: - 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 - """ - ... - - @required_args(["method", "params"]) - def handle_rpc( - self, - agent_name: str, - *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: name_handle_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, - # 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, - ) -> JSONLDecoder[object] | JSONLDecoder[object]: if not agent_name: raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") return self._post( @@ -198,13 +148,12 @@ def handle_rpc( "id": id, "jsonrpc": jsonrpc, }, - name_handle_rpc_params.NameHandleRpcParams, + name_rpc_params.NameRpcParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=JSONLDecoder[object], - stream=todo_unsupported or False, + cast_to=object, ) @@ -294,13 +243,12 @@ async def delete( cast_to=Agent, ) - @overload - async def handle_rpc( + async def rpc( self, agent_name: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: name_handle_rpc_params.Params, + params: name_rpc_params.Params, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -309,7 +257,7 @@ async def handle_rpc( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> AsyncJSONLDecoder[object]: + ) -> object: """ Handle JSON-RPC requests for an agent by its unique name. @@ -322,54 +270,6 @@ async def handle_rpc( timeout: Override the client-level default timeout for this request, in seconds """ - ... - - @overload - async def handle_rpc( - self, - agent_name: str, - *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: name_handle_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, - # 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, - ) -> AsyncJSONLDecoder[object]: - """ - Handle JSON-RPC requests for an agent by its unique name. - - Args: - 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 - """ - ... - - @required_args(["method", "params"]) - async def handle_rpc( - self, - agent_name: str, - *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: name_handle_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, - # 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, - ) -> AsyncJSONLDecoder[object] | AsyncJSONLDecoder[object]: if not agent_name: raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") return await self._post( @@ -381,13 +281,12 @@ async def handle_rpc( "id": id, "jsonrpc": jsonrpc, }, - name_handle_rpc_params.NameHandleRpcParams, + name_rpc_params.NameRpcParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AsyncJSONLDecoder[object], - stream=todo_unsupported or False, + cast_to=object, ) @@ -401,8 +300,8 @@ def __init__(self, name: NameResource) -> None: self.delete = to_raw_response_wrapper( name.delete, ) - self.handle_rpc = to_raw_response_wrapper( - name.handle_rpc, + self.rpc = to_raw_response_wrapper( + name.rpc, ) @@ -416,8 +315,8 @@ def __init__(self, name: AsyncNameResource) -> None: self.delete = async_to_raw_response_wrapper( name.delete, ) - self.handle_rpc = async_to_raw_response_wrapper( - name.handle_rpc, + self.rpc = async_to_raw_response_wrapper( + name.rpc, ) @@ -431,8 +330,8 @@ def __init__(self, name: NameResource) -> None: self.delete = to_streamed_response_wrapper( name.delete, ) - self.handle_rpc = to_streamed_response_wrapper( - name.handle_rpc, + self.rpc = to_streamed_response_wrapper( + name.rpc, ) @@ -446,6 +345,6 @@ def __init__(self, name: AsyncNameResource) -> None: self.delete = async_to_streamed_response_wrapper( name.delete, ) - self.handle_rpc = async_to_streamed_response_wrapper( - name.handle_rpc, + self.rpc = async_to_streamed_response_wrapper( + name.rpc, ) diff --git a/src/agentex_sdk/types/__init__.py b/src/agentex_sdk/types/__init__.py index 544c9db3..5dc2f002 100644 --- a/src/agentex_sdk/types/__init__.py +++ b/src/agentex_sdk/types/__init__.py @@ -13,6 +13,7 @@ from .text_content import TextContent as TextContent from .message_style import MessageStyle as MessageStyle from .message_author import MessageAuthor as MessageAuthor +from .agent_rpc_params import AgentRpcParams as AgentRpcParams from .echo_send_params import EchoSendParams as EchoSendParams from .span_list_params import SpanListParams as SpanListParams from .streaming_status import StreamingStatus as StreamingStatus @@ -41,6 +42,5 @@ from .tool_response_content import ToolResponseContent as ToolResponseContent from .tracker_list_response import TrackerListResponse as TrackerListResponse from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams -from .agent_handle_rpc_params import AgentHandleRpcParams as AgentHandleRpcParams from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam diff --git a/src/agentex_sdk/types/agent_handle_rpc_params.py b/src/agentex_sdk/types/agent_rpc_params.py similarity index 85% rename from src/agentex_sdk/types/agent_handle_rpc_params.py rename to src/agentex_sdk/types/agent_rpc_params.py index 1d2d2233..2c79a7a9 100644 --- a/src/agentex_sdk/types/agent_handle_rpc_params.py +++ b/src/agentex_sdk/types/agent_rpc_params.py @@ -11,7 +11,7 @@ from .tool_response_content_param import ToolResponseContentParam __all__ = [ - "AgentHandleRpcParamsBase", + "AgentRpcParams", "Params", "ParamsCreateTaskRequest", "ParamsCancelTaskRequest", @@ -19,11 +19,10 @@ "ParamsSendMessageRequestContent", "ParamsSendEventRequest", "ParamsSendEventRequestContent", - "AgentHandleRpcParamsNonStreaming", ] -class AgentHandleRpcParamsBase(TypedDict, total=False): +class AgentRpcParams(TypedDict, total=False): method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] params: Required[Params] @@ -84,14 +83,3 @@ class ParamsSendEventRequest(TypedDict, total=False): Params: TypeAlias = Union[ ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest ] - - -class AgentHandleRpcParamsNonStreaming(AgentHandleRpcParamsBase, total=False): - pass - - -class AgentHandleRpcParamsNonStreaming(AgentHandleRpcParamsBase, total=False): - pass - - -AgentHandleRpcParams = Union[AgentHandleRpcParamsNonStreaming, AgentHandleRpcParamsNonStreaming] diff --git a/src/agentex_sdk/types/agents/__init__.py b/src/agentex_sdk/types/agents/__init__.py index c1760c0e..6b2986a2 100644 --- a/src/agentex_sdk/types/agents/__init__.py +++ b/src/agentex_sdk/types/agents/__init__.py @@ -2,4 +2,4 @@ from __future__ import annotations -from .name_handle_rpc_params import NameHandleRpcParams as NameHandleRpcParams +from .name_rpc_params import NameRpcParams as NameRpcParams diff --git a/src/agentex_sdk/types/agents/name_handle_rpc_params.py b/src/agentex_sdk/types/agents/name_rpc_params.py similarity index 86% rename from src/agentex_sdk/types/agents/name_handle_rpc_params.py rename to src/agentex_sdk/types/agents/name_rpc_params.py index f53c09bf..6a68b0ba 100644 --- a/src/agentex_sdk/types/agents/name_handle_rpc_params.py +++ b/src/agentex_sdk/types/agents/name_rpc_params.py @@ -11,7 +11,7 @@ from ..tool_response_content_param import ToolResponseContentParam __all__ = [ - "NameHandleRpcParamsBase", + "NameRpcParams", "Params", "ParamsCreateTaskRequest", "ParamsCancelTaskRequest", @@ -19,11 +19,10 @@ "ParamsSendMessageRequestContent", "ParamsSendEventRequest", "ParamsSendEventRequestContent", - "NameHandleRpcParamsNonStreaming", ] -class NameHandleRpcParamsBase(TypedDict, total=False): +class NameRpcParams(TypedDict, total=False): method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] params: Required[Params] @@ -84,14 +83,3 @@ class ParamsSendEventRequest(TypedDict, total=False): Params: TypeAlias = Union[ ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest ] - - -class NameHandleRpcParamsNonStreaming(NameHandleRpcParamsBase, total=False): - pass - - -class NameHandleRpcParamsNonStreaming(NameHandleRpcParamsBase, total=False): - pass - - -NameHandleRpcParams = Union[NameHandleRpcParamsNonStreaming, NameHandleRpcParamsNonStreaming] diff --git a/tests/api_resources/agents/test_name.py b/tests/api_resources/agents/test_name.py index 7ee6edc1..ac850392 100644 --- a/tests/api_resources/agents/test_name.py +++ b/tests/api_resources/agents/test_name.py @@ -10,7 +10,6 @@ from agentex_sdk import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type from agentex_sdk.types import Agent -from agentex_sdk._decoders.jsonl import JSONLDecoder, AsyncJSONLDecoder base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -104,18 +103,18 @@ def test_path_params_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_handle_rpc_overload_1(self, client: AgentexSDK) -> None: - name = client.agents.name.handle_rpc( + def test_method_rpc(self, client: AgentexSDK) -> None: + name = client.agents.name.rpc( agent_name="agent_name", method="event/send", params={}, ) - assert_matches_type(JSONLDecoder[object], name, path=["response"]) + assert_matches_type(object, name, path=["response"]) @pytest.mark.skip() @parametrize - def test_method_handle_rpc_with_all_params_overload_1(self, client: AgentexSDK) -> None: - name = client.agents.name.handle_rpc( + def test_method_rpc_with_all_params(self, client: AgentexSDK) -> None: + name = client.agents.name.rpc( agent_name="agent_name", method="event/send", params={ @@ -125,12 +124,12 @@ def test_method_handle_rpc_with_all_params_overload_1(self, client: AgentexSDK) id=0, jsonrpc="2.0", ) - assert_matches_type(JSONLDecoder[object], name, path=["response"]) + assert_matches_type(object, name, path=["response"]) @pytest.mark.skip() @parametrize - def test_raw_response_handle_rpc_overload_1(self, client: AgentexSDK) -> None: - response = client.agents.name.with_raw_response.handle_rpc( + def test_raw_response_rpc(self, client: AgentexSDK) -> None: + response = client.agents.name.with_raw_response.rpc( agent_name="agent_name", method="event/send", params={}, @@ -139,12 +138,12 @@ def test_raw_response_handle_rpc_overload_1(self, client: AgentexSDK) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" name = response.parse() - assert_matches_type(JSONLDecoder[object], name, path=["response"]) + assert_matches_type(object, name, path=["response"]) @pytest.mark.skip() @parametrize - def test_streaming_response_handle_rpc_overload_1(self, client: AgentexSDK) -> None: - with client.agents.name.with_streaming_response.handle_rpc( + def test_streaming_response_rpc(self, client: AgentexSDK) -> None: + with client.agents.name.with_streaming_response.rpc( agent_name="agent_name", method="event/send", params={}, @@ -153,80 +152,15 @@ def test_streaming_response_handle_rpc_overload_1(self, client: AgentexSDK) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" name = response.parse() - assert_matches_type(JSONLDecoder[object], name, path=["response"]) + assert_matches_type(object, name, path=["response"]) assert cast(Any, response.is_closed) is True @pytest.mark.skip() @parametrize - def test_path_params_handle_rpc_overload_1(self, client: AgentexSDK) -> None: + def test_path_params_rpc(self, client: AgentexSDK) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - client.agents.name.with_raw_response.handle_rpc( - agent_name="", - method="event/send", - params={}, - ) - - @pytest.mark.skip() - @parametrize - def test_method_handle_rpc_overload_2(self, client: AgentexSDK) -> None: - name = client.agents.name.handle_rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - assert_matches_type(JSONLDecoder[object], name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_method_handle_rpc_with_all_params_overload_2(self, client: AgentexSDK) -> None: - name = client.agents.name.handle_rpc( - agent_name="agent_name", - method="event/send", - params={ - "name": "name", - "params": {"foo": "bar"}, - }, - id=0, - jsonrpc="2.0", - ) - assert_matches_type(JSONLDecoder[object], name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_handle_rpc_overload_2(self, client: AgentexSDK) -> None: - response = client.agents.name.with_raw_response.handle_rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = response.parse() - assert_matches_type(JSONLDecoder[object], name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_handle_rpc_overload_2(self, client: AgentexSDK) -> None: - with client.agents.name.with_streaming_response.handle_rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = response.parse() - assert_matches_type(JSONLDecoder[object], name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - def test_path_params_handle_rpc_overload_2(self, client: AgentexSDK) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - client.agents.name.with_raw_response.handle_rpc( + client.agents.name.with_raw_response.rpc( agent_name="", method="event/send", params={}, @@ -324,83 +258,18 @@ async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: - name = await async_client.agents.name.handle_rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_method_handle_rpc_with_all_params_overload_1(self, async_client: AsyncAgentexSDK) -> None: - name = await async_client.agents.name.handle_rpc( - agent_name="agent_name", - method="event/send", - params={ - "name": "name", - "params": {"foo": "bar"}, - }, - id=0, - jsonrpc="2.0", - ) - assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: - response = await async_client.agents.name.with_raw_response.handle_rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = await response.parse() - assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: - async with async_client.agents.name.with_streaming_response.handle_rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = await response.parse() - assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - async def test_path_params_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - await async_client.agents.name.with_raw_response.handle_rpc( - agent_name="", - method="event/send", - params={}, - ) - - @pytest.mark.skip() - @parametrize - async def test_method_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: - name = await async_client.agents.name.handle_rpc( + async def test_method_rpc(self, async_client: AsyncAgentexSDK) -> None: + name = await async_client.agents.name.rpc( agent_name="agent_name", method="event/send", params={}, ) - assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) + assert_matches_type(object, name, path=["response"]) @pytest.mark.skip() @parametrize - async def test_method_handle_rpc_with_all_params_overload_2(self, async_client: AsyncAgentexSDK) -> None: - name = await async_client.agents.name.handle_rpc( + async def test_method_rpc_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + name = await async_client.agents.name.rpc( agent_name="agent_name", method="event/send", params={ @@ -410,12 +279,12 @@ async def test_method_handle_rpc_with_all_params_overload_2(self, async_client: id=0, jsonrpc="2.0", ) - assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) + assert_matches_type(object, name, path=["response"]) @pytest.mark.skip() @parametrize - async def test_raw_response_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: - response = await async_client.agents.name.with_raw_response.handle_rpc( + async def test_raw_response_rpc(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.agents.name.with_raw_response.rpc( agent_name="agent_name", method="event/send", params={}, @@ -424,12 +293,12 @@ async def test_raw_response_handle_rpc_overload_2(self, async_client: AsyncAgent assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" name = await response.parse() - assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) + assert_matches_type(object, name, path=["response"]) @pytest.mark.skip() @parametrize - async def test_streaming_response_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: - async with async_client.agents.name.with_streaming_response.handle_rpc( + async def test_streaming_response_rpc(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.agents.name.with_streaming_response.rpc( agent_name="agent_name", method="event/send", params={}, @@ -438,15 +307,15 @@ async def test_streaming_response_handle_rpc_overload_2(self, async_client: Asyn assert response.http_request.headers.get("X-Stainless-Lang") == "python" name = await response.parse() - assert_matches_type(AsyncJSONLDecoder[object], name, path=["response"]) + assert_matches_type(object, name, path=["response"]) assert cast(Any, response.is_closed) is True @pytest.mark.skip() @parametrize - async def test_path_params_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_rpc(self, async_client: AsyncAgentexSDK) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - await async_client.agents.name.with_raw_response.handle_rpc( + await async_client.agents.name.with_raw_response.rpc( agent_name="", method="event/send", params={}, diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index 3b298619..f7072a9d 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -13,7 +13,6 @@ Agent, AgentListResponse, ) -from agentex_sdk._decoders.jsonl import JSONLDecoder, AsyncJSONLDecoder base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -143,83 +142,73 @@ def test_path_params_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_handle_rpc_overload_1(self, client: AgentexSDK) -> None: - agent = client.agents.handle_rpc( - agent_id="agent_id", - method="event/send", - params={}, + def test_method_register(self, client: AgentexSDK) -> None: + agent = client.agents.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", ) - assert_matches_type(JSONLDecoder[object], agent, path=["response"]) + assert_matches_type(Agent, agent, path=["response"]) @pytest.mark.skip() @parametrize - def test_method_handle_rpc_with_all_params_overload_1(self, client: AgentexSDK) -> None: - agent = client.agents.handle_rpc( + def test_method_register_with_all_params(self, client: AgentexSDK) -> None: + agent = client.agents.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", agent_id="agent_id", - method="event/send", - params={ - "name": "name", - "params": {"foo": "bar"}, - }, - id=0, - jsonrpc="2.0", ) - assert_matches_type(JSONLDecoder[object], agent, path=["response"]) + assert_matches_type(Agent, agent, path=["response"]) @pytest.mark.skip() @parametrize - def test_raw_response_handle_rpc_overload_1(self, client: AgentexSDK) -> None: - response = client.agents.with_raw_response.handle_rpc( - agent_id="agent_id", - method="event/send", - params={}, + def test_raw_response_register(self, client: AgentexSDK) -> None: + response = client.agents.with_raw_response.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(JSONLDecoder[object], agent, path=["response"]) + assert_matches_type(Agent, agent, path=["response"]) @pytest.mark.skip() @parametrize - def test_streaming_response_handle_rpc_overload_1(self, client: AgentexSDK) -> None: - with client.agents.with_streaming_response.handle_rpc( - agent_id="agent_id", - method="event/send", - params={}, + def test_streaming_response_register(self, client: AgentexSDK) -> None: + with client.agents.with_streaming_response.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(JSONLDecoder[object], agent, path=["response"]) + assert_matches_type(Agent, agent, path=["response"]) assert cast(Any, response.is_closed) is True @pytest.mark.skip() @parametrize - def test_path_params_handle_rpc_overload_1(self, client: AgentexSDK) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): - client.agents.with_raw_response.handle_rpc( - agent_id="", - method="event/send", - params={}, - ) - - @pytest.mark.skip() - @parametrize - def test_method_handle_rpc_overload_2(self, client: AgentexSDK) -> None: - agent = client.agents.handle_rpc( + def test_method_rpc(self, client: AgentexSDK) -> None: + agent = client.agents.rpc( agent_id="agent_id", method="event/send", params={}, ) - assert_matches_type(JSONLDecoder[object], agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize - def test_method_handle_rpc_with_all_params_overload_2(self, client: AgentexSDK) -> None: - agent = client.agents.handle_rpc( + def test_method_rpc_with_all_params(self, client: AgentexSDK) -> None: + agent = client.agents.rpc( agent_id="agent_id", method="event/send", params={ @@ -229,12 +218,12 @@ def test_method_handle_rpc_with_all_params_overload_2(self, client: AgentexSDK) id=0, jsonrpc="2.0", ) - assert_matches_type(JSONLDecoder[object], agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize - def test_raw_response_handle_rpc_overload_2(self, client: AgentexSDK) -> None: - response = client.agents.with_raw_response.handle_rpc( + def test_raw_response_rpc(self, client: AgentexSDK) -> None: + response = client.agents.with_raw_response.rpc( agent_id="agent_id", method="event/send", params={}, @@ -243,12 +232,12 @@ def test_raw_response_handle_rpc_overload_2(self, client: AgentexSDK) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(JSONLDecoder[object], agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize - def test_streaming_response_handle_rpc_overload_2(self, client: AgentexSDK) -> None: - with client.agents.with_streaming_response.handle_rpc( + def test_streaming_response_rpc(self, client: AgentexSDK) -> None: + with client.agents.with_streaming_response.rpc( agent_id="agent_id", method="event/send", params={}, @@ -257,75 +246,20 @@ def test_streaming_response_handle_rpc_overload_2(self, client: AgentexSDK) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(JSONLDecoder[object], agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) assert cast(Any, response.is_closed) is True @pytest.mark.skip() @parametrize - def test_path_params_handle_rpc_overload_2(self, client: AgentexSDK) -> None: + def test_path_params_rpc(self, client: AgentexSDK) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): - client.agents.with_raw_response.handle_rpc( + client.agents.with_raw_response.rpc( agent_id="", method="event/send", params={}, ) - @pytest.mark.skip() - @parametrize - def test_method_register(self, client: AgentexSDK) -> None: - agent = client.agents.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - ) - assert_matches_type(Agent, agent, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_method_register_with_all_params(self, client: AgentexSDK) -> None: - agent = client.agents.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - agent_id="agent_id", - ) - assert_matches_type(Agent, agent, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_register(self, client: AgentexSDK) -> None: - response = client.agents.with_raw_response.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - agent = response.parse() - assert_matches_type(Agent, agent, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_register(self, client: AgentexSDK) -> None: - with client.agents.with_streaming_response.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - agent = response.parse() - assert_matches_type(Agent, agent, path=["response"]) - - assert cast(Any, response.is_closed) is True - class TestAsyncAgents: parametrize = pytest.mark.parametrize( @@ -454,83 +388,73 @@ async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: - agent = await async_client.agents.handle_rpc( - agent_id="agent_id", - method="event/send", - params={}, + async def test_method_register(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", ) - assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) + assert_matches_type(Agent, agent, path=["response"]) @pytest.mark.skip() @parametrize - async def test_method_handle_rpc_with_all_params_overload_1(self, async_client: AsyncAgentexSDK) -> None: - agent = await async_client.agents.handle_rpc( + async def test_method_register_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", agent_id="agent_id", - method="event/send", - params={ - "name": "name", - "params": {"foo": "bar"}, - }, - id=0, - jsonrpc="2.0", ) - assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) + assert_matches_type(Agent, agent, path=["response"]) @pytest.mark.skip() @parametrize - async def test_raw_response_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: - response = await async_client.agents.with_raw_response.handle_rpc( - agent_id="agent_id", - method="event/send", - params={}, + async def test_raw_response_register(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.agents.with_raw_response.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) + assert_matches_type(Agent, agent, path=["response"]) @pytest.mark.skip() @parametrize - async def test_streaming_response_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: - async with async_client.agents.with_streaming_response.handle_rpc( - agent_id="agent_id", - method="event/send", - params={}, + async def test_streaming_response_register(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.agents.with_streaming_response.register( + acp_type="sync", + acp_url="acp_url", + description="description", + name="name", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) + assert_matches_type(Agent, agent, path=["response"]) assert cast(Any, response.is_closed) is True @pytest.mark.skip() @parametrize - async def test_path_params_handle_rpc_overload_1(self, async_client: AsyncAgentexSDK) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): - await async_client.agents.with_raw_response.handle_rpc( - agent_id="", - method="event/send", - params={}, - ) - - @pytest.mark.skip() - @parametrize - async def test_method_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: - agent = await async_client.agents.handle_rpc( + async def test_method_rpc(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.rpc( agent_id="agent_id", method="event/send", params={}, ) - assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize - async def test_method_handle_rpc_with_all_params_overload_2(self, async_client: AsyncAgentexSDK) -> None: - agent = await async_client.agents.handle_rpc( + async def test_method_rpc_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + agent = await async_client.agents.rpc( agent_id="agent_id", method="event/send", params={ @@ -540,12 +464,12 @@ async def test_method_handle_rpc_with_all_params_overload_2(self, async_client: id=0, jsonrpc="2.0", ) - assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize - async def test_raw_response_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: - response = await async_client.agents.with_raw_response.handle_rpc( + async def test_raw_response_rpc(self, async_client: AsyncAgentexSDK) -> None: + response = await async_client.agents.with_raw_response.rpc( agent_id="agent_id", method="event/send", params={}, @@ -554,12 +478,12 @@ async def test_raw_response_handle_rpc_overload_2(self, async_client: AsyncAgent assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize - async def test_streaming_response_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: - async with async_client.agents.with_streaming_response.handle_rpc( + async def test_streaming_response_rpc(self, async_client: AsyncAgentexSDK) -> None: + async with async_client.agents.with_streaming_response.rpc( agent_id="agent_id", method="event/send", params={}, @@ -568,71 +492,16 @@ async def test_streaming_response_handle_rpc_overload_2(self, async_client: Asyn assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AsyncJSONLDecoder[object], agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) assert cast(Any, response.is_closed) is True @pytest.mark.skip() @parametrize - async def test_path_params_handle_rpc_overload_2(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_rpc(self, async_client: AsyncAgentexSDK) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): - await async_client.agents.with_raw_response.handle_rpc( + await async_client.agents.with_raw_response.rpc( agent_id="", method="event/send", params={}, ) - - @pytest.mark.skip() - @parametrize - async def test_method_register(self, async_client: AsyncAgentexSDK) -> None: - agent = await async_client.agents.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - ) - assert_matches_type(Agent, agent, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_method_register_with_all_params(self, async_client: AsyncAgentexSDK) -> None: - agent = await async_client.agents.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - agent_id="agent_id", - ) - assert_matches_type(Agent, agent, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_register(self, async_client: AsyncAgentexSDK) -> None: - response = await async_client.agents.with_raw_response.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - agent = await response.parse() - assert_matches_type(Agent, agent, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_register(self, async_client: AsyncAgentexSDK) -> None: - async with async_client.agents.with_streaming_response.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - agent = await response.parse() - assert_matches_type(Agent, agent, path=["response"]) - - assert cast(Any, response.is_closed) is True diff --git a/tests/decoders/test_jsonl.py b/tests/decoders/test_jsonl.py deleted file mode 100644 index 26f32b3d..00000000 --- a/tests/decoders/test_jsonl.py +++ /dev/null @@ -1,88 +0,0 @@ -from __future__ import annotations - -from typing import Any, Iterator, AsyncIterator -from typing_extensions import TypeVar - -import httpx -import pytest - -from agentex_sdk._decoders.jsonl import JSONLDecoder, AsyncJSONLDecoder - -_T = TypeVar("_T") - - -@pytest.mark.asyncio -@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) -async def test_basic(sync: bool) -> None: - def body() -> Iterator[bytes]: - yield b'{"foo":true}\n' - yield b'{"bar":false}\n' - - iterator = make_jsonl_iterator( - content=body(), - sync=sync, - line_type=object, - ) - - assert await iter_next(iterator) == {"foo": True} - assert await iter_next(iterator) == {"bar": False} - - await assert_empty_iter(iterator) - - -@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) -async def test_new_lines_in_json( - sync: bool, -) -> None: - def body() -> Iterator[bytes]: - yield b'{"content":"Hello, world!\\nHow are you doing?"}' - - iterator = make_jsonl_iterator(content=body(), sync=sync, line_type=object) - - assert await iter_next(iterator) == {"content": "Hello, world!\nHow are you doing?"} - - -@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) -async def test_multi_byte_character_multiple_chunks( - sync: bool, -) -> None: - def body() -> Iterator[bytes]: - yield b'{"content":"' - # bytes taken from the string 'известни' and arbitrarily split - # so that some multi-byte characters span multiple chunks - yield b"\xd0" - yield b"\xb8\xd0\xb7\xd0" - yield b"\xb2\xd0\xb5\xd1\x81\xd1\x82\xd0\xbd\xd0\xb8" - yield b'"}\n' - - iterator = make_jsonl_iterator(content=body(), sync=sync, line_type=object) - - assert await iter_next(iterator) == {"content": "известни"} - - -async def to_aiter(iter: Iterator[bytes]) -> AsyncIterator[bytes]: - for chunk in iter: - yield chunk - - -async def iter_next(iter: Iterator[_T] | AsyncIterator[_T]) -> _T: - if isinstance(iter, AsyncIterator): - return await iter.__anext__() - return next(iter) - - -async def assert_empty_iter(decoder: JSONLDecoder[Any] | AsyncJSONLDecoder[Any]) -> None: - with pytest.raises((StopAsyncIteration, RuntimeError)): - await iter_next(decoder) - - -def make_jsonl_iterator( - content: Iterator[bytes], - *, - sync: bool, - line_type: type[_T], -) -> JSONLDecoder[_T] | AsyncJSONLDecoder[_T]: - if sync: - return JSONLDecoder(line_type=line_type, raw_iterator=content, http_response=httpx.Response(200)) - - return AsyncJSONLDecoder(line_type=line_type, raw_iterator=to_aiter(content), http_response=httpx.Response(200)) From 78c52dbb68bcd4fdbbc939d4e5baa0f01dcbb19d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 17 Jul 2025 15:40:59 +0000 Subject: [PATCH 0007/1108] feat(api): update via SDK Studio --- .stats.yml | 4 +- api.md | 1 - src/agentex_sdk/resources/agents/agents.py | 125 +----------------- src/agentex_sdk/types/__init__.py | 1 - .../types/agent_register_params.py | 27 ---- tests/api_resources/test_agents.py | 115 +--------------- 6 files changed, 4 insertions(+), 269 deletions(-) delete mode 100644 src/agentex_sdk/types/agent_register_params.py diff --git a/.stats.yml b/.stats.yml index cf8fb92d..95b7d2e8 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 37 +configured_endpoints: 36 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-7a38e3675674c19ea4fa2ca0cfef23aa1d96dbdb29ca3ba4194b0e858d0a4ee0.yml openapi_spec_hash: 55a7eae5bc606e4ac91841d7e675723e -config_hash: fbda9c84b0140c8ae711ef5e6aaf1f31 +config_hash: a27cbab8582313e3443934631c648e1f diff --git a/api.md b/api.md index 2583c643..1d29eda3 100644 --- a/api.md +++ b/api.md @@ -23,7 +23,6 @@ Methods: - client.agents.retrieve(agent_id) -> Agent - client.agents.list(\*\*params) -> AgentListResponse - client.agents.delete(agent_id) -> Agent -- client.agents.register(\*\*params) -> Agent - client.agents.rpc(agent_id, \*\*params) -> object ## Name diff --git a/src/agentex_sdk/resources/agents/agents.py b/src/agentex_sdk/resources/agents/agents.py index 17642e0b..b6a49a76 100644 --- a/src/agentex_sdk/resources/agents/agents.py +++ b/src/agentex_sdk/resources/agents/agents.py @@ -15,7 +15,7 @@ NameResourceWithStreamingResponse, AsyncNameResourceWithStreamingResponse, ) -from ...types import AcpType, agent_rpc_params, agent_list_params, agent_register_params +from ...types import agent_rpc_params, agent_list_params from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property @@ -28,7 +28,6 @@ ) from ...types.agent import Agent from ..._base_client import make_request_options -from ...types.acp_type import AcpType from ...types.agent_list_response import AgentListResponse __all__ = ["AgentsResource", "AsyncAgentsResource"] @@ -161,61 +160,6 @@ def delete( cast_to=Agent, ) - def register( - self, - *, - acp_type: AcpType, - acp_url: str, - description: str, - name: str, - agent_id: Optional[str] | NotGiven = NOT_GIVEN, - # 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, - ) -> Agent: - """ - Register a new agent or update an existing one. - - Args: - acp_type: The type of ACP to use for the agent. - - acp_url: The URL of the ACP server for the agent. - - description: The description of the agent. - - name: The unique name of the agent. - - agent_id: Optional agent ID if the agent already exists and needs to be updated. - - 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 - """ - return self._post( - "/agents/register", - body=maybe_transform( - { - "acp_type": acp_type, - "acp_url": acp_url, - "description": description, - "name": name, - "agent_id": agent_id, - }, - agent_register_params.AgentRegisterParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Agent, - ) - def rpc( self, agent_id: str, @@ -390,61 +334,6 @@ async def delete( cast_to=Agent, ) - async def register( - self, - *, - acp_type: AcpType, - acp_url: str, - description: str, - name: str, - agent_id: Optional[str] | NotGiven = NOT_GIVEN, - # 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, - ) -> Agent: - """ - Register a new agent or update an existing one. - - Args: - acp_type: The type of ACP to use for the agent. - - acp_url: The URL of the ACP server for the agent. - - description: The description of the agent. - - name: The unique name of the agent. - - agent_id: Optional agent ID if the agent already exists and needs to be updated. - - 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 - """ - return await self._post( - "/agents/register", - body=await async_maybe_transform( - { - "acp_type": acp_type, - "acp_url": acp_url, - "description": description, - "name": name, - "agent_id": agent_id, - }, - agent_register_params.AgentRegisterParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Agent, - ) - async def rpc( self, agent_id: str, @@ -505,9 +394,6 @@ def __init__(self, agents: AgentsResource) -> None: self.delete = to_raw_response_wrapper( agents.delete, ) - self.register = to_raw_response_wrapper( - agents.register, - ) self.rpc = to_raw_response_wrapper( agents.rpc, ) @@ -530,9 +416,6 @@ def __init__(self, agents: AsyncAgentsResource) -> None: self.delete = async_to_raw_response_wrapper( agents.delete, ) - self.register = async_to_raw_response_wrapper( - agents.register, - ) self.rpc = async_to_raw_response_wrapper( agents.rpc, ) @@ -555,9 +438,6 @@ def __init__(self, agents: AgentsResource) -> None: self.delete = to_streamed_response_wrapper( agents.delete, ) - self.register = to_streamed_response_wrapper( - agents.register, - ) self.rpc = to_streamed_response_wrapper( agents.rpc, ) @@ -580,9 +460,6 @@ def __init__(self, agents: AsyncAgentsResource) -> None: self.delete = async_to_streamed_response_wrapper( agents.delete, ) - self.register = async_to_streamed_response_wrapper( - agents.register, - ) self.rpc = async_to_streamed_response_wrapper( agents.rpc, ) diff --git a/src/agentex_sdk/types/__init__.py b/src/agentex_sdk/types/__init__.py index 5dc2f002..17dc3aa2 100644 --- a/src/agentex_sdk/types/__init__.py +++ b/src/agentex_sdk/types/__init__.py @@ -35,7 +35,6 @@ from .state_update_params import StateUpdateParams as StateUpdateParams from .tracker_list_params import TrackerListParams as TrackerListParams from .tool_request_content import ToolRequestContent as ToolRequestContent -from .agent_register_params import AgentRegisterParams as AgentRegisterParams from .message_create_params import MessageCreateParams as MessageCreateParams from .message_list_response import MessageListResponse as MessageListResponse from .message_update_params import MessageUpdateParams as MessageUpdateParams diff --git a/src/agentex_sdk/types/agent_register_params.py b/src/agentex_sdk/types/agent_register_params.py deleted file mode 100644 index 9b8b6dd3..00000000 --- a/src/agentex_sdk/types/agent_register_params.py +++ /dev/null @@ -1,27 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Optional -from typing_extensions import Required, TypedDict - -from .acp_type import AcpType - -__all__ = ["AgentRegisterParams"] - - -class AgentRegisterParams(TypedDict, total=False): - acp_type: Required[AcpType] - """The type of ACP to use for the agent.""" - - acp_url: Required[str] - """The URL of the ACP server for the agent.""" - - description: Required[str] - """The description of the agent.""" - - name: Required[str] - """The unique name of the agent.""" - - agent_id: Optional[str] - """Optional agent ID if the agent already exists and needs to be updated.""" diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index f7072a9d..96e39991 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -9,10 +9,7 @@ from agentex_sdk import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type -from agentex_sdk.types import ( - Agent, - AgentListResponse, -) +from agentex_sdk.types import Agent, AgentListResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -140,61 +137,6 @@ def test_path_params_delete(self, client: AgentexSDK) -> None: "", ) - @pytest.mark.skip() - @parametrize - def test_method_register(self, client: AgentexSDK) -> None: - agent = client.agents.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - ) - assert_matches_type(Agent, agent, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_method_register_with_all_params(self, client: AgentexSDK) -> None: - agent = client.agents.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - agent_id="agent_id", - ) - assert_matches_type(Agent, agent, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_register(self, client: AgentexSDK) -> None: - response = client.agents.with_raw_response.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - agent = response.parse() - assert_matches_type(Agent, agent, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_register(self, client: AgentexSDK) -> None: - with client.agents.with_streaming_response.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - agent = response.parse() - assert_matches_type(Agent, agent, path=["response"]) - - assert cast(Any, response.is_closed) is True - @pytest.mark.skip() @parametrize def test_method_rpc(self, client: AgentexSDK) -> None: @@ -386,61 +328,6 @@ async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: "", ) - @pytest.mark.skip() - @parametrize - async def test_method_register(self, async_client: AsyncAgentexSDK) -> None: - agent = await async_client.agents.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - ) - assert_matches_type(Agent, agent, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_method_register_with_all_params(self, async_client: AsyncAgentexSDK) -> None: - agent = await async_client.agents.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - agent_id="agent_id", - ) - assert_matches_type(Agent, agent, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_register(self, async_client: AsyncAgentexSDK) -> None: - response = await async_client.agents.with_raw_response.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - agent = await response.parse() - assert_matches_type(Agent, agent, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_register(self, async_client: AsyncAgentexSDK) -> None: - async with async_client.agents.with_streaming_response.register( - acp_type="sync", - acp_url="acp_url", - description="description", - name="name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - agent = await response.parse() - assert_matches_type(Agent, agent, path=["response"]) - - assert cast(Any, response.is_closed) is True - @pytest.mark.skip() @parametrize async def test_method_rpc(self, async_client: AsyncAgentexSDK) -> None: From 42b0c8d5867aa0e6d00c3ce7325f8e12f4dde727 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 17 Jul 2025 16:34:13 +0000 Subject: [PATCH 0008/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 95b7d2e8..792b354d 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 36 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-7a38e3675674c19ea4fa2ca0cfef23aa1d96dbdb29ca3ba4194b0e858d0a4ee0.yml -openapi_spec_hash: 55a7eae5bc606e4ac91841d7e675723e +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-e8ce15a00ebbfb8be199c0172a95616741cb872a8d346bd039cdde45153ec79c.yml +openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 config_hash: a27cbab8582313e3443934631c648e1f From aebf56e46e51153acdc857fc8d0a7675ddc6657a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 17 Jul 2025 22:17:23 +0000 Subject: [PATCH 0009/1108] feat(api): manual updates --- .stats.yml | 6 ++--- api.md | 2 +- src/agentex_sdk/types/__init__.py | 1 + src/agentex_sdk/types/agent_rpc_params.py | 21 ++------------- .../types/agents/name_rpc_params.py | 21 ++------------- .../types/send_event_request_param.py | 26 +++++++++++++++++++ 6 files changed, 35 insertions(+), 42 deletions(-) create mode 100644 src/agentex_sdk/types/send_event_request_param.py diff --git a/.stats.yml b/.stats.yml index 792b354d..03b47b01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 36 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-e8ce15a00ebbfb8be199c0172a95616741cb872a8d346bd039cdde45153ec79c.yml -openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 -config_hash: a27cbab8582313e3443934631c648e1f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-7a38e3675674c19ea4fa2ca0cfef23aa1d96dbdb29ca3ba4194b0e858d0a4ee0.yml +openapi_spec_hash: 55a7eae5bc606e4ac91841d7e675723e +config_hash: f38bab4291bf4c9b70b80777314caff8 diff --git a/api.md b/api.md index 1d29eda3..d7747057 100644 --- a/api.md +++ b/api.md @@ -15,7 +15,7 @@ Methods: Types: ```python -from agentex_sdk.types import AcpType, Agent, AgentRpcRequest, AgentListResponse +from agentex_sdk.types import AcpType, Agent, AgentRpcRequest, SendEventRequest, AgentListResponse ``` Methods: diff --git a/src/agentex_sdk/types/__init__.py b/src/agentex_sdk/types/__init__.py index 17dc3aa2..9a11ae34 100644 --- a/src/agentex_sdk/types/__init__.py +++ b/src/agentex_sdk/types/__init__.py @@ -41,5 +41,6 @@ from .tool_response_content import ToolResponseContent as ToolResponseContent from .tracker_list_response import TrackerListResponse as TrackerListResponse from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams +from .send_event_request_param import SendEventRequestParam as SendEventRequestParam from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam diff --git a/src/agentex_sdk/types/agent_rpc_params.py b/src/agentex_sdk/types/agent_rpc_params.py index 2c79a7a9..89dbdca0 100644 --- a/src/agentex_sdk/types/agent_rpc_params.py +++ b/src/agentex_sdk/types/agent_rpc_params.py @@ -7,6 +7,7 @@ from .data_content_param import DataContentParam from .text_content_param import TextContentParam +from .send_event_request_param import SendEventRequestParam from .tool_request_content_param import ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam @@ -17,8 +18,6 @@ "ParamsCancelTaskRequest", "ParamsSendMessageRequest", "ParamsSendMessageRequestContent", - "ParamsSendEventRequest", - "ParamsSendEventRequestContent", ] @@ -64,22 +63,6 @@ class ParamsSendMessageRequest(TypedDict, total=False): """The ID of the task that the message was sent to""" -ParamsSendEventRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendEventRequest(TypedDict, total=False): - content: Optional[ParamsSendEventRequestContent] - """The content to send to the event""" - - task_id: Optional[str] - """The ID of the task that the event was sent to""" - - task_name: Optional[str] - """The name of the task that the event was sent to""" - - Params: TypeAlias = Union[ - ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest + ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, SendEventRequestParam ] diff --git a/src/agentex_sdk/types/agents/name_rpc_params.py b/src/agentex_sdk/types/agents/name_rpc_params.py index 6a68b0ba..590710c3 100644 --- a/src/agentex_sdk/types/agents/name_rpc_params.py +++ b/src/agentex_sdk/types/agents/name_rpc_params.py @@ -7,6 +7,7 @@ from ..data_content_param import DataContentParam from ..text_content_param import TextContentParam +from ..send_event_request_param import SendEventRequestParam from ..tool_request_content_param import ToolRequestContentParam from ..tool_response_content_param import ToolResponseContentParam @@ -17,8 +18,6 @@ "ParamsCancelTaskRequest", "ParamsSendMessageRequest", "ParamsSendMessageRequestContent", - "ParamsSendEventRequest", - "ParamsSendEventRequestContent", ] @@ -64,22 +63,6 @@ class ParamsSendMessageRequest(TypedDict, total=False): """The ID of the task that the message was sent to""" -ParamsSendEventRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendEventRequest(TypedDict, total=False): - content: Optional[ParamsSendEventRequestContent] - """The content to send to the event""" - - task_id: Optional[str] - """The ID of the task that the event was sent to""" - - task_name: Optional[str] - """The name of the task that the event was sent to""" - - Params: TypeAlias = Union[ - ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest + ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, SendEventRequestParam ] diff --git a/src/agentex_sdk/types/send_event_request_param.py b/src/agentex_sdk/types/send_event_request_param.py new file mode 100644 index 00000000..e1142a7b --- /dev/null +++ b/src/agentex_sdk/types/send_event_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 import Union, Optional +from typing_extensions import TypeAlias, TypedDict + +from .data_content_param import DataContentParam +from .text_content_param import TextContentParam +from .tool_request_content_param import ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam + +__all__ = ["SendEventRequestParam", "Content"] + +Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] + + +class SendEventRequestParam(TypedDict, total=False): + content: Optional[Content] + """The content to send to the event""" + + task_id: Optional[str] + """The ID of the task that the event was sent to""" + + task_name: Optional[str] + """The name of the task that the event was sent to""" From 894aea025adf42fdfb443c49e8ab0aa23731114f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 17 Jul 2025 22:23:41 +0000 Subject: [PATCH 0010/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 03b47b01..ed0541e8 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 36 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-7a38e3675674c19ea4fa2ca0cfef23aa1d96dbdb29ca3ba4194b0e858d0a4ee0.yml -openapi_spec_hash: 55a7eae5bc606e4ac91841d7e675723e +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-e8ce15a00ebbfb8be199c0172a95616741cb872a8d346bd039cdde45153ec79c.yml +openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 config_hash: f38bab4291bf4c9b70b80777314caff8 From 35ead6fe123641d57b27c241aea80256de05cbd6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 17 Jul 2025 23:51:47 +0000 Subject: [PATCH 0011/1108] feat(api): manual updates --- .stats.yml | 2 +- CONTRIBUTING.md | 2 +- README.md | 48 +++++----- api.md | 88 +++++++++---------- mypy.ini | 2 +- pyproject.toml | 10 +-- requirements-dev.lock | 16 ++-- requirements.lock | 16 ++-- scripts/lint | 2 +- src/{agentex_sdk => agentex}/__init__.py | 4 +- src/{agentex_sdk => agentex}/_base_client.py | 2 +- src/{agentex_sdk => agentex}/_client.py | 0 src/{agentex_sdk => agentex}/_compat.py | 0 src/{agentex_sdk => agentex}/_constants.py | 0 src/{agentex_sdk => agentex}/_exceptions.py | 0 src/{agentex_sdk => agentex}/_files.py | 0 src/{agentex_sdk => agentex}/_models.py | 0 src/{agentex_sdk => agentex}/_qs.py | 0 src/{agentex_sdk => agentex}/_resource.py | 0 src/{agentex_sdk => agentex}/_response.py | 10 +-- src/{agentex_sdk => agentex}/_streaming.py | 0 src/{agentex_sdk => agentex}/_types.py | 2 +- .../_utils/__init__.py | 0 src/{agentex_sdk => agentex}/_utils/_logs.py | 4 +- src/{agentex_sdk => agentex}/_utils/_proxy.py | 0 .../_utils/_reflection.py | 0 .../_utils/_resources_proxy.py | 8 +- .../_utils/_streams.py | 0 src/{agentex_sdk => agentex}/_utils/_sync.py | 0 .../_utils/_transform.py | 0 .../_utils/_typing.py | 0 src/{agentex_sdk => agentex}/_utils/_utils.py | 0 src/{agentex_sdk => agentex}/_version.py | 2 +- src/agentex/lib/.keep | 4 + src/{agentex_sdk => agentex}/py.typed | 0 .../resources/__init__.py | 0 .../resources/agents/__init__.py | 0 .../resources/agents/agents.py | 0 .../resources/agents/name.py | 0 .../resources/echo.py | 0 .../resources/events.py | 0 .../resources/messages/__init__.py | 0 .../resources/messages/batch.py | 0 .../resources/messages/messages.py | 0 .../resources/spans.py | 0 .../resources/states.py | 0 .../resources/tasks/__init__.py | 0 .../resources/tasks/name.py | 0 .../resources/tasks/tasks.py | 0 .../resources/tracker.py | 0 .../types/__init__.py | 0 .../types/acp_type.py | 0 src/{agentex_sdk => agentex}/types/agent.py | 0 .../types/agent_list_params.py | 0 .../types/agent_list_response.py | 0 .../types/agent_rpc_params.py | 0 .../types/agent_task_tracker.py | 0 .../types/agents/__init__.py | 0 .../types/agents/name_rpc_params.py | 0 .../types/data_content.py | 0 .../types/data_content_param.py | 0 .../types/echo_send_params.py | 0 src/{agentex_sdk => agentex}/types/event.py | 0 .../types/event_list_params.py | 0 .../types/event_list_response.py | 0 .../types/message_author.py | 0 .../types/message_create_params.py | 0 .../types/message_list_params.py | 0 .../types/message_list_response.py | 0 .../types/message_style.py | 0 .../types/message_update_params.py | 0 .../types/messages/__init__.py | 0 .../types/messages/batch_create_params.py | 0 .../types/messages/batch_create_response.py | 0 .../types/messages/batch_update_params.py | 0 .../types/messages/batch_update_response.py | 0 .../types/send_event_request_param.py | 0 src/{agentex_sdk => agentex}/types/span.py | 0 .../types/span_create_params.py | 0 .../types/span_list_params.py | 0 .../types/span_list_response.py | 0 .../types/span_update_params.py | 0 src/{agentex_sdk => agentex}/types/state.py | 0 .../types/state_create_params.py | 0 .../types/state_list_params.py | 0 .../types/state_list_response.py | 0 .../types/state_update_params.py | 0 .../types/streaming_status.py | 0 src/{agentex_sdk => agentex}/types/task.py | 0 .../types/task_list_response.py | 0 .../types/task_message.py | 0 .../types/tasks/__init__.py | 0 .../types/text_content.py | 0 .../types/text_content_param.py | 0 .../types/tool_request_content.py | 0 .../types/tool_request_content_param.py | 0 .../types/tool_response_content.py | 0 .../types/tool_response_content_param.py | 0 .../types/tracker_list_params.py | 0 .../types/tracker_list_response.py | 0 .../types/tracker_update_params.py | 0 tests/api_resources/agents/test_name.py | 4 +- tests/api_resources/messages/test_batch.py | 7 +- tests/api_resources/tasks/test_name.py | 4 +- tests/api_resources/test_agents.py | 4 +- tests/api_resources/test_client.py | 2 +- tests/api_resources/test_echo.py | 2 +- tests/api_resources/test_events.py | 4 +- tests/api_resources/test_messages.py | 4 +- tests/api_resources/test_spans.py | 6 +- tests/api_resources/test_states.py | 4 +- tests/api_resources/test_tasks.py | 4 +- tests/api_resources/test_tracker.py | 4 +- tests/conftest.py | 6 +- tests/test_client.py | 46 +++++----- tests/test_deepcopy.py | 2 +- tests/test_extract_files.py | 4 +- tests/test_files.py | 2 +- tests/test_models.py | 6 +- tests/test_qs.py | 2 +- tests/test_required_args.py | 2 +- tests/test_response.py | 14 +-- tests/test_streaming.py | 4 +- tests/test_transform.py | 8 +- tests/test_utils/test_proxy.py | 2 +- tests/test_utils/test_typing.py | 2 +- tests/utils.py | 8 +- 127 files changed, 189 insertions(+), 190 deletions(-) rename src/{agentex_sdk => agentex}/__init__.py (95%) rename src/{agentex_sdk => agentex}/_base_client.py (99%) rename src/{agentex_sdk => agentex}/_client.py (100%) rename src/{agentex_sdk => agentex}/_compat.py (100%) rename src/{agentex_sdk => agentex}/_constants.py (100%) rename src/{agentex_sdk => agentex}/_exceptions.py (100%) rename src/{agentex_sdk => agentex}/_files.py (100%) rename src/{agentex_sdk => agentex}/_models.py (100%) rename src/{agentex_sdk => agentex}/_qs.py (100%) rename src/{agentex_sdk => agentex}/_resource.py (100%) rename src/{agentex_sdk => agentex}/_response.py (98%) rename src/{agentex_sdk => agentex}/_streaming.py (100%) rename src/{agentex_sdk => agentex}/_types.py (99%) rename src/{agentex_sdk => agentex}/_utils/__init__.py (100%) rename src/{agentex_sdk => agentex}/_utils/_logs.py (76%) rename src/{agentex_sdk => agentex}/_utils/_proxy.py (100%) rename src/{agentex_sdk => agentex}/_utils/_reflection.py (100%) rename src/{agentex_sdk => agentex}/_utils/_resources_proxy.py (51%) rename src/{agentex_sdk => agentex}/_utils/_streams.py (100%) rename src/{agentex_sdk => agentex}/_utils/_sync.py (100%) rename src/{agentex_sdk => agentex}/_utils/_transform.py (100%) rename src/{agentex_sdk => agentex}/_utils/_typing.py (100%) rename src/{agentex_sdk => agentex}/_utils/_utils.py (100%) rename src/{agentex_sdk => agentex}/_version.py (81%) create mode 100644 src/agentex/lib/.keep rename src/{agentex_sdk => agentex}/py.typed (100%) rename src/{agentex_sdk => agentex}/resources/__init__.py (100%) rename src/{agentex_sdk => agentex}/resources/agents/__init__.py (100%) rename src/{agentex_sdk => agentex}/resources/agents/agents.py (100%) rename src/{agentex_sdk => agentex}/resources/agents/name.py (100%) rename src/{agentex_sdk => agentex}/resources/echo.py (100%) rename src/{agentex_sdk => agentex}/resources/events.py (100%) rename src/{agentex_sdk => agentex}/resources/messages/__init__.py (100%) rename src/{agentex_sdk => agentex}/resources/messages/batch.py (100%) rename src/{agentex_sdk => agentex}/resources/messages/messages.py (100%) rename src/{agentex_sdk => agentex}/resources/spans.py (100%) rename src/{agentex_sdk => agentex}/resources/states.py (100%) rename src/{agentex_sdk => agentex}/resources/tasks/__init__.py (100%) rename src/{agentex_sdk => agentex}/resources/tasks/name.py (100%) rename src/{agentex_sdk => agentex}/resources/tasks/tasks.py (100%) rename src/{agentex_sdk => agentex}/resources/tracker.py (100%) rename src/{agentex_sdk => agentex}/types/__init__.py (100%) rename src/{agentex_sdk => agentex}/types/acp_type.py (100%) rename src/{agentex_sdk => agentex}/types/agent.py (100%) rename src/{agentex_sdk => agentex}/types/agent_list_params.py (100%) rename src/{agentex_sdk => agentex}/types/agent_list_response.py (100%) rename src/{agentex_sdk => agentex}/types/agent_rpc_params.py (100%) rename src/{agentex_sdk => agentex}/types/agent_task_tracker.py (100%) rename src/{agentex_sdk => agentex}/types/agents/__init__.py (100%) rename src/{agentex_sdk => agentex}/types/agents/name_rpc_params.py (100%) rename src/{agentex_sdk => agentex}/types/data_content.py (100%) rename src/{agentex_sdk => agentex}/types/data_content_param.py (100%) rename src/{agentex_sdk => agentex}/types/echo_send_params.py (100%) rename src/{agentex_sdk => agentex}/types/event.py (100%) rename src/{agentex_sdk => agentex}/types/event_list_params.py (100%) rename src/{agentex_sdk => agentex}/types/event_list_response.py (100%) rename src/{agentex_sdk => agentex}/types/message_author.py (100%) rename src/{agentex_sdk => agentex}/types/message_create_params.py (100%) rename src/{agentex_sdk => agentex}/types/message_list_params.py (100%) rename src/{agentex_sdk => agentex}/types/message_list_response.py (100%) rename src/{agentex_sdk => agentex}/types/message_style.py (100%) rename src/{agentex_sdk => agentex}/types/message_update_params.py (100%) rename src/{agentex_sdk => agentex}/types/messages/__init__.py (100%) rename src/{agentex_sdk => agentex}/types/messages/batch_create_params.py (100%) rename src/{agentex_sdk => agentex}/types/messages/batch_create_response.py (100%) rename src/{agentex_sdk => agentex}/types/messages/batch_update_params.py (100%) rename src/{agentex_sdk => agentex}/types/messages/batch_update_response.py (100%) rename src/{agentex_sdk => agentex}/types/send_event_request_param.py (100%) rename src/{agentex_sdk => agentex}/types/span.py (100%) rename src/{agentex_sdk => agentex}/types/span_create_params.py (100%) rename src/{agentex_sdk => agentex}/types/span_list_params.py (100%) rename src/{agentex_sdk => agentex}/types/span_list_response.py (100%) rename src/{agentex_sdk => agentex}/types/span_update_params.py (100%) rename src/{agentex_sdk => agentex}/types/state.py (100%) rename src/{agentex_sdk => agentex}/types/state_create_params.py (100%) rename src/{agentex_sdk => agentex}/types/state_list_params.py (100%) rename src/{agentex_sdk => agentex}/types/state_list_response.py (100%) rename src/{agentex_sdk => agentex}/types/state_update_params.py (100%) rename src/{agentex_sdk => agentex}/types/streaming_status.py (100%) rename src/{agentex_sdk => agentex}/types/task.py (100%) rename src/{agentex_sdk => agentex}/types/task_list_response.py (100%) rename src/{agentex_sdk => agentex}/types/task_message.py (100%) rename src/{agentex_sdk => agentex}/types/tasks/__init__.py (100%) rename src/{agentex_sdk => agentex}/types/text_content.py (100%) rename src/{agentex_sdk => agentex}/types/text_content_param.py (100%) rename src/{agentex_sdk => agentex}/types/tool_request_content.py (100%) rename src/{agentex_sdk => agentex}/types/tool_request_content_param.py (100%) rename src/{agentex_sdk => agentex}/types/tool_response_content.py (100%) rename src/{agentex_sdk => agentex}/types/tool_response_content_param.py (100%) rename src/{agentex_sdk => agentex}/types/tracker_list_params.py (100%) rename src/{agentex_sdk => agentex}/types/tracker_list_response.py (100%) rename src/{agentex_sdk => agentex}/types/tracker_update_params.py (100%) diff --git a/.stats.yml b/.stats.yml index ed0541e8..11b5c649 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 36 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-e8ce15a00ebbfb8be199c0172a95616741cb872a8d346bd039cdde45153ec79c.yml openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 -config_hash: f38bab4291bf4c9b70b80777314caff8 +config_hash: 00be5715c3420ef99bce1df3a24947d1 diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 27a8c1c5..7b6c64be 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -36,7 +36,7 @@ $ pip install -r requirements-dev.lock Most of the SDK is generated code. Modifications to code will be persisted between generations, but may result in merge conflicts between manual patches and changes from the generator. The generator will never -modify the contents of the `src/agentex_sdk/lib/` and `examples/` directories. +modify the contents of the `src/agentex/lib/` and `examples/` directories. ## Adding and running examples diff --git a/README.md b/README.md index b42d80fb..852a5a7b 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ # Agentex SDK Python API library -[![PyPI version](https://img.shields.io/pypi/v/agentex_sdk.svg?label=pypi%20(stable))](https://pypi.org/project/agentex_sdk/) +[![PyPI version](https://img.shields.io/pypi/v/agentex.svg?label=pypi%20(stable))](https://pypi.org/project/agentex/) The Agentex SDK Python library provides convenient access to the Agentex SDK REST API from any Python 3.8+ application. The library includes type definitions for all request params and response fields, @@ -21,7 +21,7 @@ pip install git+ssh://git@github.com/stainless-sdks/agentex-sdk-python.git ``` > [!NOTE] -> Once this package is [published to PyPI](https://www.stainless.com/docs/guides/publish), this will become: `pip install --pre agentex_sdk` +> Once this package is [published to PyPI](https://www.stainless.com/docs/guides/publish), this will become: `pip install --pre agentex` ## Usage @@ -29,7 +29,7 @@ The full API of this library can be found in [api.md](api.md). ```python import os -from agentex_sdk import AgentexSDK +from agentex import AgentexSDK client = AgentexSDK( api_key=os.environ.get("AGENTEX_SDK_API_KEY"), # This is the default and can be omitted @@ -52,7 +52,7 @@ Simply import `AsyncAgentexSDK` instead of `AgentexSDK` and use `await` with eac ```python import os import asyncio -from agentex_sdk import AsyncAgentexSDK +from agentex import AsyncAgentexSDK client = AsyncAgentexSDK( api_key=os.environ.get("AGENTEX_SDK_API_KEY"), # This is the default and can be omitted @@ -78,15 +78,15 @@ You can enable this by installing `aiohttp`: ```sh # install from this staging repo -pip install 'agentex_sdk[aiohttp] @ git+ssh://git@github.com/stainless-sdks/agentex-sdk-python.git' +pip install 'agentex[aiohttp] @ git+ssh://git@github.com/stainless-sdks/agentex-sdk-python.git' ``` Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`: ```python import asyncio -from agentex_sdk import DefaultAioHttpClient -from agentex_sdk import AsyncAgentexSDK +from agentex import DefaultAioHttpClient +from agentex import AsyncAgentexSDK async def main() -> None: @@ -113,16 +113,16 @@ Typed requests and responses provide autocomplete and documentation within your ## Handling errors -When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `agentex_sdk.APIConnectionError` is raised. +When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `agentex.APIConnectionError` is raised. When the API returns a non-success status code (that is, 4xx or 5xx -response), a subclass of `agentex_sdk.APIStatusError` is raised, containing `status_code` and `response` properties. +response), a subclass of `agentex.APIStatusError` is raised, containing `status_code` and `response` properties. -All errors inherit from `agentex_sdk.APIError`. +All errors inherit from `agentex.APIError`. ```python -import agentex_sdk -from agentex_sdk import AgentexSDK +import agentex +from agentex import AgentexSDK client = AgentexSDK() @@ -130,12 +130,12 @@ try: client.echo.send( message="message", ) -except agentex_sdk.APIConnectionError as e: +except agentex.APIConnectionError as e: print("The server could not be reached") print(e.__cause__) # an underlying Exception, likely raised within httpx. -except agentex_sdk.RateLimitError as e: +except agentex.RateLimitError as e: print("A 429 status code was received; we should back off a bit.") -except agentex_sdk.APIStatusError as e: +except agentex.APIStatusError as e: print("Another non-200-range status code was received") print(e.status_code) print(e.response) @@ -163,7 +163,7 @@ Connection errors (for example, due to a network connectivity problem), 408 Requ You can use the `max_retries` option to configure or disable retry settings: ```python -from agentex_sdk import AgentexSDK +from agentex import AgentexSDK # Configure the default for all requests: client = AgentexSDK( @@ -183,7 +183,7 @@ By default requests time out after 1 minute. You can configure this with a `time which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/timeouts/#fine-tuning-the-configuration) object: ```python -from agentex_sdk import AgentexSDK +from agentex import AgentexSDK # Configure the default for all requests: client = AgentexSDK( @@ -237,7 +237,7 @@ if response.my_field is None: The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g., ```py -from agentex_sdk import AgentexSDK +from agentex import AgentexSDK client = AgentexSDK() response = client.echo.with_raw_response.send( @@ -249,9 +249,9 @@ echo = response.parse() # get the object that `echo.send()` would have returned print(echo) ``` -These methods return an [`APIResponse`](https://github.com/stainless-sdks/agentex-sdk-python/tree/main/src/agentex_sdk/_response.py) object. +These methods return an [`APIResponse`](https://github.com/stainless-sdks/agentex-sdk-python/tree/main/src/agentex/_response.py) object. -The async client returns an [`AsyncAPIResponse`](https://github.com/stainless-sdks/agentex-sdk-python/tree/main/src/agentex_sdk/_response.py) with the same structure, the only difference being `await`able methods for reading the response content. +The async client returns an [`AsyncAPIResponse`](https://github.com/stainless-sdks/agentex-sdk-python/tree/main/src/agentex/_response.py) with the same structure, the only difference being `await`able methods for reading the response content. #### `.with_streaming_response` @@ -315,7 +315,7 @@ You can directly override the [httpx client](https://www.python-httpx.org/api/#c ```python import httpx -from agentex_sdk import AgentexSDK, DefaultHttpxClient +from agentex import AgentexSDK, DefaultHttpxClient client = AgentexSDK( # Or use the `AGENTEX_SDK_BASE_URL` env var @@ -338,7 +338,7 @@ client.with_options(http_client=DefaultHttpxClient(...)) By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting. ```py -from agentex_sdk import AgentexSDK +from agentex import AgentexSDK with AgentexSDK() as client: # make requests here @@ -366,8 +366,8 @@ If you've upgraded to the latest version but aren't seeing any new features you You can determine the version that is being used at runtime with: ```py -import agentex_sdk -print(agentex_sdk.__version__) +import agentex +print(agentex.__version__) ``` ## Requirements diff --git a/api.md b/api.md index d7747057..aab9f936 100644 --- a/api.md +++ b/api.md @@ -2,66 +2,66 @@ Methods: -- client.get_root() -> object +- client.get_root() -> object # Echo Methods: -- client.echo.send(\*\*params) -> object +- client.echo.send(\*\*params) -> object # Agents Types: ```python -from agentex_sdk.types import AcpType, Agent, AgentRpcRequest, SendEventRequest, AgentListResponse +from agentex.types import AcpType, Agent, AgentRpcRequest, SendEventRequest, AgentListResponse ``` Methods: -- client.agents.retrieve(agent_id) -> Agent -- client.agents.list(\*\*params) -> AgentListResponse -- client.agents.delete(agent_id) -> Agent -- client.agents.rpc(agent_id, \*\*params) -> object +- client.agents.retrieve(agent_id) -> Agent +- client.agents.list(\*\*params) -> AgentListResponse +- client.agents.delete(agent_id) -> Agent +- client.agents.rpc(agent_id, \*\*params) -> object ## Name Methods: -- client.agents.name.retrieve(agent_name) -> Agent -- client.agents.name.delete(agent_name) -> Agent -- client.agents.name.rpc(agent_name, \*\*params) -> object +- client.agents.name.retrieve(agent_name) -> Agent +- client.agents.name.delete(agent_name) -> Agent +- client.agents.name.rpc(agent_name, \*\*params) -> object # Tasks Types: ```python -from agentex_sdk.types import Task, TaskListResponse +from agentex.types import Task, TaskListResponse ``` Methods: -- client.tasks.retrieve(task_id) -> Task -- client.tasks.list() -> TaskListResponse -- client.tasks.delete(task_id) -> Task -- client.tasks.stream_events(task_id) -> object +- client.tasks.retrieve(task_id) -> Task +- client.tasks.list() -> TaskListResponse +- client.tasks.delete(task_id) -> Task +- client.tasks.stream_events(task_id) -> object ## Name Methods: -- client.tasks.name.retrieve(task_name) -> Task -- client.tasks.name.delete(task_name) -> Task -- client.tasks.name.stream_events(task_name) -> object +- client.tasks.name.retrieve(task_name) -> Task +- client.tasks.name.delete(task_name) -> Task +- client.tasks.name.stream_events(task_name) -> object # Messages Types: ```python -from agentex_sdk.types import ( +from agentex.types import ( DataContent, MessageAuthor, MessageStyle, @@ -76,78 +76,78 @@ from agentex_sdk.types import ( Methods: -- client.messages.create(\*\*params) -> TaskMessage -- client.messages.retrieve(message_id) -> TaskMessage -- client.messages.update(message_id, \*\*params) -> TaskMessage -- client.messages.list(\*\*params) -> MessageListResponse +- client.messages.create(\*\*params) -> TaskMessage +- client.messages.retrieve(message_id) -> TaskMessage +- client.messages.update(message_id, \*\*params) -> TaskMessage +- client.messages.list(\*\*params) -> MessageListResponse ## Batch Types: ```python -from agentex_sdk.types.messages import BatchCreateResponse, BatchUpdateResponse +from agentex.types.messages import BatchCreateResponse, BatchUpdateResponse ``` Methods: -- client.messages.batch.create(\*\*params) -> BatchCreateResponse -- client.messages.batch.update(\*\*params) -> BatchUpdateResponse +- client.messages.batch.create(\*\*params) -> BatchCreateResponse +- client.messages.batch.update(\*\*params) -> BatchUpdateResponse # Spans Types: ```python -from agentex_sdk.types import Span, SpanListResponse +from agentex.types import Span, SpanListResponse ``` Methods: -- client.spans.create(\*\*params) -> Span -- client.spans.retrieve(span_id) -> Span -- client.spans.update(span_id, \*\*params) -> Span -- client.spans.list(\*\*params) -> SpanListResponse +- client.spans.create(\*\*params) -> Span +- client.spans.retrieve(span_id) -> Span +- client.spans.update(span_id, \*\*params) -> Span +- client.spans.list(\*\*params) -> SpanListResponse # States Types: ```python -from agentex_sdk.types import State, StateListResponse +from agentex.types import State, StateListResponse ``` Methods: -- client.states.create(\*\*params) -> State -- client.states.retrieve(state_id) -> State -- client.states.update(state_id, \*\*params) -> State -- client.states.list(\*\*params) -> StateListResponse -- client.states.delete(state_id) -> State +- client.states.create(\*\*params) -> State +- client.states.retrieve(state_id) -> State +- client.states.update(state_id, \*\*params) -> State +- client.states.list(\*\*params) -> StateListResponse +- client.states.delete(state_id) -> State # Events Types: ```python -from agentex_sdk.types import Event, EventListResponse +from agentex.types import Event, EventListResponse ``` Methods: -- client.events.retrieve(event_id) -> Event -- client.events.list(\*\*params) -> EventListResponse +- client.events.retrieve(event_id) -> Event +- client.events.list(\*\*params) -> EventListResponse # Tracker Types: ```python -from agentex_sdk.types import AgentTaskTracker, TrackerListResponse +from agentex.types import AgentTaskTracker, TrackerListResponse ``` Methods: -- client.tracker.retrieve(tracker_id) -> AgentTaskTracker -- client.tracker.update(tracker_id, \*\*params) -> AgentTaskTracker -- client.tracker.list(\*\*params) -> TrackerListResponse +- client.tracker.retrieve(tracker_id) -> AgentTaskTracker +- client.tracker.update(tracker_id, \*\*params) -> AgentTaskTracker +- client.tracker.list(\*\*params) -> TrackerListResponse diff --git a/mypy.ini b/mypy.ini index 5af2c510..91619053 100644 --- a/mypy.ini +++ b/mypy.ini @@ -8,7 +8,7 @@ show_error_codes = True # # We also exclude our `tests` as mypy doesn't always infer # types correctly and Pyright will still catch any type errors. -exclude = ^(src/agentex_sdk/_files\.py|_dev/.*\.py|tests/.*)$ +exclude = ^(src/agentex/_files\.py|_dev/.*\.py|tests/.*)$ strict_equality = True implicit_reexport = True diff --git a/pyproject.toml b/pyproject.toml index 3d289ba7..608ee777 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,5 +1,5 @@ [project] -name = "agentex_sdk" +name = "agentex" version = "0.0.1-alpha.0" description = "The official Python library for the agentex-sdk API" dynamic = ["readme"] @@ -79,14 +79,14 @@ format = { chain = [ "check:ruff" = "ruff check ." "fix:ruff" = "ruff check --fix ." -"check:importable" = "python -c 'import agentex_sdk'" +"check:importable" = "python -c 'import agentex'" typecheck = { chain = [ "typecheck:pyright", "typecheck:mypy" ]} "typecheck:pyright" = "pyright" -"typecheck:verify-types" = "pyright --verifytypes agentex_sdk --ignoreexternal" +"typecheck:verify-types" = "pyright --verifytypes agentex --ignoreexternal" "typecheck:mypy" = "mypy ." [build-system] @@ -99,7 +99,7 @@ include = [ ] [tool.hatch.build.targets.wheel] -packages = ["src/agentex_sdk"] +packages = ["src/agentex"] [tool.hatch.build.targets.sdist] # Basically everything except hidden files/directories (such as .github, .devcontainers, .python-version, etc) @@ -202,7 +202,7 @@ length-sort = true length-sort-straight = true combine-as-imports = true extra-standard-library = ["typing_extensions"] -known-first-party = ["agentex_sdk", "tests"] +known-first-party = ["agentex", "tests"] [tool.ruff.lint.per-file-ignores] "bin/**.py" = ["T201", "T203"] diff --git a/requirements-dev.lock b/requirements-dev.lock index 56a38441..f82de72c 100644 --- a/requirements-dev.lock +++ b/requirements-dev.lock @@ -13,14 +13,14 @@ aiohappyeyeballs==2.6.1 # via aiohttp aiohttp==3.12.8 - # via agentex-sdk + # via agentex # via httpx-aiohttp aiosignal==1.3.2 # via aiohttp annotated-types==0.6.0 # via pydantic anyio==4.4.0 - # via agentex-sdk + # via agentex # via httpx argcomplete==3.1.2 # via nox @@ -37,7 +37,7 @@ dirty-equals==0.6.0 distlib==0.3.7 # via virtualenv distro==1.8.0 - # via agentex-sdk + # via agentex exceptiongroup==1.2.2 # via anyio # via pytest @@ -53,11 +53,11 @@ h11==0.16.0 httpcore==1.0.9 # via httpx httpx==0.28.1 - # via agentex-sdk + # via agentex # via httpx-aiohttp # via respx httpx-aiohttp==0.1.8 - # via agentex-sdk + # via agentex idna==3.4 # via anyio # via httpx @@ -90,7 +90,7 @@ propcache==0.3.1 # via aiohttp # via yarl pydantic==2.10.3 - # via agentex-sdk + # via agentex pydantic-core==2.27.1 # via pydantic pygments==2.18.0 @@ -113,14 +113,14 @@ setuptools==68.2.2 six==1.16.0 # via python-dateutil sniffio==1.3.0 - # via agentex-sdk + # via agentex # via anyio time-machine==2.9.0 tomli==2.0.2 # via mypy # via pytest typing-extensions==4.12.2 - # via agentex-sdk + # via agentex # via anyio # via multidict # via mypy diff --git a/requirements.lock b/requirements.lock index a4e7e943..a6d3556d 100644 --- a/requirements.lock +++ b/requirements.lock @@ -13,14 +13,14 @@ aiohappyeyeballs==2.6.1 # via aiohttp aiohttp==3.12.8 - # via agentex-sdk + # via agentex # via httpx-aiohttp aiosignal==1.3.2 # via aiohttp annotated-types==0.6.0 # via pydantic anyio==4.4.0 - # via agentex-sdk + # via agentex # via httpx async-timeout==5.0.1 # via aiohttp @@ -30,7 +30,7 @@ certifi==2023.7.22 # via httpcore # via httpx distro==1.8.0 - # via agentex-sdk + # via agentex exceptiongroup==1.2.2 # via anyio frozenlist==1.6.2 @@ -41,10 +41,10 @@ h11==0.16.0 httpcore==1.0.9 # via httpx httpx==0.28.1 - # via agentex-sdk + # via agentex # via httpx-aiohttp httpx-aiohttp==0.1.8 - # via agentex-sdk + # via agentex idna==3.4 # via anyio # via httpx @@ -56,14 +56,14 @@ propcache==0.3.1 # via aiohttp # via yarl pydantic==2.10.3 - # via agentex-sdk + # via agentex pydantic-core==2.27.1 # via pydantic sniffio==1.3.0 - # via agentex-sdk + # via agentex # via anyio typing-extensions==4.12.2 - # via agentex-sdk + # via agentex # via anyio # via multidict # via pydantic diff --git a/scripts/lint b/scripts/lint index 3788432a..69fa62e9 100755 --- a/scripts/lint +++ b/scripts/lint @@ -8,4 +8,4 @@ echo "==> Running lints" rye run lint echo "==> Making sure it imports" -rye run python -c 'import agentex_sdk' +rye run python -c 'import agentex' diff --git a/src/agentex_sdk/__init__.py b/src/agentex/__init__.py similarity index 95% rename from src/agentex_sdk/__init__.py rename to src/agentex/__init__.py index 6f29658e..7aaf8252 100644 --- a/src/agentex_sdk/__init__.py +++ b/src/agentex/__init__.py @@ -89,12 +89,12 @@ # Update the __module__ attribute for exported symbols so that # error messages point to this module instead of the module # it was originally defined in, e.g. -# agentex_sdk._exceptions.NotFoundError -> agentex_sdk.NotFoundError +# agentex._exceptions.NotFoundError -> agentex.NotFoundError __locals = locals() for __name in __all__: if not __name.startswith("__"): try: - __locals[__name].__module__ = "agentex_sdk" + __locals[__name].__module__ = "agentex" except (TypeError, AttributeError): # Some of our exported symbols are builtins which we can't set attributes for. pass diff --git a/src/agentex_sdk/_base_client.py b/src/agentex/_base_client.py similarity index 99% rename from src/agentex_sdk/_base_client.py rename to src/agentex/_base_client.py index a68e0526..0cc1fbb7 100644 --- a/src/agentex_sdk/_base_client.py +++ b/src/agentex/_base_client.py @@ -389,7 +389,7 @@ def __init__( if max_retries is None: # pyright: ignore[reportUnnecessaryComparison] raise TypeError( - "max_retries cannot be None. If you want to disable retries, pass `0`; if you want unlimited retries, pass `math.inf` or a very high number; if you want the default behavior, pass `agentex_sdk.DEFAULT_MAX_RETRIES`" + "max_retries cannot be None. If you want to disable retries, pass `0`; if you want unlimited retries, pass `math.inf` or a very high number; if you want the default behavior, pass `agentex.DEFAULT_MAX_RETRIES`" ) def _enforce_trailing_slash(self, url: URL) -> URL: diff --git a/src/agentex_sdk/_client.py b/src/agentex/_client.py similarity index 100% rename from src/agentex_sdk/_client.py rename to src/agentex/_client.py diff --git a/src/agentex_sdk/_compat.py b/src/agentex/_compat.py similarity index 100% rename from src/agentex_sdk/_compat.py rename to src/agentex/_compat.py diff --git a/src/agentex_sdk/_constants.py b/src/agentex/_constants.py similarity index 100% rename from src/agentex_sdk/_constants.py rename to src/agentex/_constants.py diff --git a/src/agentex_sdk/_exceptions.py b/src/agentex/_exceptions.py similarity index 100% rename from src/agentex_sdk/_exceptions.py rename to src/agentex/_exceptions.py diff --git a/src/agentex_sdk/_files.py b/src/agentex/_files.py similarity index 100% rename from src/agentex_sdk/_files.py rename to src/agentex/_files.py diff --git a/src/agentex_sdk/_models.py b/src/agentex/_models.py similarity index 100% rename from src/agentex_sdk/_models.py rename to src/agentex/_models.py diff --git a/src/agentex_sdk/_qs.py b/src/agentex/_qs.py similarity index 100% rename from src/agentex_sdk/_qs.py rename to src/agentex/_qs.py diff --git a/src/agentex_sdk/_resource.py b/src/agentex/_resource.py similarity index 100% rename from src/agentex_sdk/_resource.py rename to src/agentex/_resource.py diff --git a/src/agentex_sdk/_response.py b/src/agentex/_response.py similarity index 98% rename from src/agentex_sdk/_response.py rename to src/agentex/_response.py index d8115d31..760047a9 100644 --- a/src/agentex_sdk/_response.py +++ b/src/agentex/_response.py @@ -217,9 +217,7 @@ def _parse(self, *, to: type[_T] | None = None) -> R | _T: and not issubclass(origin, BaseModel) and issubclass(origin, pydantic.BaseModel) ): - raise TypeError( - "Pydantic models must subclass our base model type, e.g. `from agentex_sdk import BaseModel`" - ) + raise TypeError("Pydantic models must subclass our base model type, e.g. `from agentex import BaseModel`") if ( cast_to is not object @@ -285,7 +283,7 @@ def parse(self, *, to: type[_T] | None = None) -> R | _T: the `to` argument, e.g. ```py - from agentex_sdk import BaseModel + from agentex import BaseModel class MyModel(BaseModel): @@ -387,7 +385,7 @@ async def parse(self, *, to: type[_T] | None = None) -> R | _T: the `to` argument, e.g. ```py - from agentex_sdk import BaseModel + from agentex import BaseModel class MyModel(BaseModel): @@ -558,7 +556,7 @@ async def stream_to_file( class MissingStreamClassError(TypeError): def __init__(self) -> None: super().__init__( - "The `stream` argument was set to `True` but the `stream_cls` argument was not given. See `agentex_sdk._streaming` for reference", + "The `stream` argument was set to `True` but the `stream_cls` argument was not given. See `agentex._streaming` for reference", ) diff --git a/src/agentex_sdk/_streaming.py b/src/agentex/_streaming.py similarity index 100% rename from src/agentex_sdk/_streaming.py rename to src/agentex/_streaming.py diff --git a/src/agentex_sdk/_types.py b/src/agentex/_types.py similarity index 99% rename from src/agentex_sdk/_types.py rename to src/agentex/_types.py index 187b412b..d01de4b1 100644 --- a/src/agentex_sdk/_types.py +++ b/src/agentex/_types.py @@ -81,7 +81,7 @@ # This unfortunately means that you will either have # to import this type and pass it explicitly: # -# from agentex_sdk import NoneType +# from agentex import NoneType # client.get('/foo', cast_to=NoneType) # # or build it yourself: diff --git a/src/agentex_sdk/_utils/__init__.py b/src/agentex/_utils/__init__.py similarity index 100% rename from src/agentex_sdk/_utils/__init__.py rename to src/agentex/_utils/__init__.py diff --git a/src/agentex_sdk/_utils/_logs.py b/src/agentex/_utils/_logs.py similarity index 76% rename from src/agentex_sdk/_utils/_logs.py rename to src/agentex/_utils/_logs.py index d94b1704..f24bd049 100644 --- a/src/agentex_sdk/_utils/_logs.py +++ b/src/agentex/_utils/_logs.py @@ -1,12 +1,12 @@ import os import logging -logger: logging.Logger = logging.getLogger("agentex_sdk") +logger: logging.Logger = logging.getLogger("agentex") httpx_logger: logging.Logger = logging.getLogger("httpx") def _basic_config() -> None: - # e.g. [2023-10-05 14:12:26 - agentex_sdk._base_client:818 - DEBUG] HTTP Request: POST http://127.0.0.1:4010/foo/bar "200 OK" + # e.g. [2023-10-05 14:12:26 - agentex._base_client:818 - DEBUG] HTTP Request: POST http://127.0.0.1:4010/foo/bar "200 OK" logging.basicConfig( format="[%(asctime)s - %(name)s:%(lineno)d - %(levelname)s] %(message)s", datefmt="%Y-%m-%d %H:%M:%S", diff --git a/src/agentex_sdk/_utils/_proxy.py b/src/agentex/_utils/_proxy.py similarity index 100% rename from src/agentex_sdk/_utils/_proxy.py rename to src/agentex/_utils/_proxy.py diff --git a/src/agentex_sdk/_utils/_reflection.py b/src/agentex/_utils/_reflection.py similarity index 100% rename from src/agentex_sdk/_utils/_reflection.py rename to src/agentex/_utils/_reflection.py diff --git a/src/agentex_sdk/_utils/_resources_proxy.py b/src/agentex/_utils/_resources_proxy.py similarity index 51% rename from src/agentex_sdk/_utils/_resources_proxy.py rename to src/agentex/_utils/_resources_proxy.py index 2cc2f9db..6ab8fc88 100644 --- a/src/agentex_sdk/_utils/_resources_proxy.py +++ b/src/agentex/_utils/_resources_proxy.py @@ -7,17 +7,17 @@ class ResourcesProxy(LazyProxy[Any]): - """A proxy for the `agentex_sdk.resources` module. + """A proxy for the `agentex.resources` module. - This is used so that we can lazily import `agentex_sdk.resources` only when - needed *and* so that users can just import `agentex_sdk` and reference `agentex_sdk.resources` + This is used so that we can lazily import `agentex.resources` only when + needed *and* so that users can just import `agentex` and reference `agentex.resources` """ @override def __load__(self) -> Any: import importlib - mod = importlib.import_module("agentex_sdk.resources") + mod = importlib.import_module("agentex.resources") return mod diff --git a/src/agentex_sdk/_utils/_streams.py b/src/agentex/_utils/_streams.py similarity index 100% rename from src/agentex_sdk/_utils/_streams.py rename to src/agentex/_utils/_streams.py diff --git a/src/agentex_sdk/_utils/_sync.py b/src/agentex/_utils/_sync.py similarity index 100% rename from src/agentex_sdk/_utils/_sync.py rename to src/agentex/_utils/_sync.py diff --git a/src/agentex_sdk/_utils/_transform.py b/src/agentex/_utils/_transform.py similarity index 100% rename from src/agentex_sdk/_utils/_transform.py rename to src/agentex/_utils/_transform.py diff --git a/src/agentex_sdk/_utils/_typing.py b/src/agentex/_utils/_typing.py similarity index 100% rename from src/agentex_sdk/_utils/_typing.py rename to src/agentex/_utils/_typing.py diff --git a/src/agentex_sdk/_utils/_utils.py b/src/agentex/_utils/_utils.py similarity index 100% rename from src/agentex_sdk/_utils/_utils.py rename to src/agentex/_utils/_utils.py diff --git a/src/agentex_sdk/_version.py b/src/agentex/_version.py similarity index 81% rename from src/agentex_sdk/_version.py rename to src/agentex/_version.py index c88b548c..4c86089c 100644 --- a/src/agentex_sdk/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -__title__ = "agentex_sdk" +__title__ = "agentex" __version__ = "0.0.1-alpha.0" diff --git a/src/agentex/lib/.keep b/src/agentex/lib/.keep new file mode 100644 index 00000000..5e2c99fd --- /dev/null +++ b/src/agentex/lib/.keep @@ -0,0 +1,4 @@ +File generated from our OpenAPI spec by Stainless. + +This directory can be used to store custom files to expand the SDK. +It is ignored by Stainless code generation and its content (other than this keep file) won't be touched. \ No newline at end of file diff --git a/src/agentex_sdk/py.typed b/src/agentex/py.typed similarity index 100% rename from src/agentex_sdk/py.typed rename to src/agentex/py.typed diff --git a/src/agentex_sdk/resources/__init__.py b/src/agentex/resources/__init__.py similarity index 100% rename from src/agentex_sdk/resources/__init__.py rename to src/agentex/resources/__init__.py diff --git a/src/agentex_sdk/resources/agents/__init__.py b/src/agentex/resources/agents/__init__.py similarity index 100% rename from src/agentex_sdk/resources/agents/__init__.py rename to src/agentex/resources/agents/__init__.py diff --git a/src/agentex_sdk/resources/agents/agents.py b/src/agentex/resources/agents/agents.py similarity index 100% rename from src/agentex_sdk/resources/agents/agents.py rename to src/agentex/resources/agents/agents.py diff --git a/src/agentex_sdk/resources/agents/name.py b/src/agentex/resources/agents/name.py similarity index 100% rename from src/agentex_sdk/resources/agents/name.py rename to src/agentex/resources/agents/name.py diff --git a/src/agentex_sdk/resources/echo.py b/src/agentex/resources/echo.py similarity index 100% rename from src/agentex_sdk/resources/echo.py rename to src/agentex/resources/echo.py diff --git a/src/agentex_sdk/resources/events.py b/src/agentex/resources/events.py similarity index 100% rename from src/agentex_sdk/resources/events.py rename to src/agentex/resources/events.py diff --git a/src/agentex_sdk/resources/messages/__init__.py b/src/agentex/resources/messages/__init__.py similarity index 100% rename from src/agentex_sdk/resources/messages/__init__.py rename to src/agentex/resources/messages/__init__.py diff --git a/src/agentex_sdk/resources/messages/batch.py b/src/agentex/resources/messages/batch.py similarity index 100% rename from src/agentex_sdk/resources/messages/batch.py rename to src/agentex/resources/messages/batch.py diff --git a/src/agentex_sdk/resources/messages/messages.py b/src/agentex/resources/messages/messages.py similarity index 100% rename from src/agentex_sdk/resources/messages/messages.py rename to src/agentex/resources/messages/messages.py diff --git a/src/agentex_sdk/resources/spans.py b/src/agentex/resources/spans.py similarity index 100% rename from src/agentex_sdk/resources/spans.py rename to src/agentex/resources/spans.py diff --git a/src/agentex_sdk/resources/states.py b/src/agentex/resources/states.py similarity index 100% rename from src/agentex_sdk/resources/states.py rename to src/agentex/resources/states.py diff --git a/src/agentex_sdk/resources/tasks/__init__.py b/src/agentex/resources/tasks/__init__.py similarity index 100% rename from src/agentex_sdk/resources/tasks/__init__.py rename to src/agentex/resources/tasks/__init__.py diff --git a/src/agentex_sdk/resources/tasks/name.py b/src/agentex/resources/tasks/name.py similarity index 100% rename from src/agentex_sdk/resources/tasks/name.py rename to src/agentex/resources/tasks/name.py diff --git a/src/agentex_sdk/resources/tasks/tasks.py b/src/agentex/resources/tasks/tasks.py similarity index 100% rename from src/agentex_sdk/resources/tasks/tasks.py rename to src/agentex/resources/tasks/tasks.py diff --git a/src/agentex_sdk/resources/tracker.py b/src/agentex/resources/tracker.py similarity index 100% rename from src/agentex_sdk/resources/tracker.py rename to src/agentex/resources/tracker.py diff --git a/src/agentex_sdk/types/__init__.py b/src/agentex/types/__init__.py similarity index 100% rename from src/agentex_sdk/types/__init__.py rename to src/agentex/types/__init__.py diff --git a/src/agentex_sdk/types/acp_type.py b/src/agentex/types/acp_type.py similarity index 100% rename from src/agentex_sdk/types/acp_type.py rename to src/agentex/types/acp_type.py diff --git a/src/agentex_sdk/types/agent.py b/src/agentex/types/agent.py similarity index 100% rename from src/agentex_sdk/types/agent.py rename to src/agentex/types/agent.py diff --git a/src/agentex_sdk/types/agent_list_params.py b/src/agentex/types/agent_list_params.py similarity index 100% rename from src/agentex_sdk/types/agent_list_params.py rename to src/agentex/types/agent_list_params.py diff --git a/src/agentex_sdk/types/agent_list_response.py b/src/agentex/types/agent_list_response.py similarity index 100% rename from src/agentex_sdk/types/agent_list_response.py rename to src/agentex/types/agent_list_response.py diff --git a/src/agentex_sdk/types/agent_rpc_params.py b/src/agentex/types/agent_rpc_params.py similarity index 100% rename from src/agentex_sdk/types/agent_rpc_params.py rename to src/agentex/types/agent_rpc_params.py diff --git a/src/agentex_sdk/types/agent_task_tracker.py b/src/agentex/types/agent_task_tracker.py similarity index 100% rename from src/agentex_sdk/types/agent_task_tracker.py rename to src/agentex/types/agent_task_tracker.py diff --git a/src/agentex_sdk/types/agents/__init__.py b/src/agentex/types/agents/__init__.py similarity index 100% rename from src/agentex_sdk/types/agents/__init__.py rename to src/agentex/types/agents/__init__.py diff --git a/src/agentex_sdk/types/agents/name_rpc_params.py b/src/agentex/types/agents/name_rpc_params.py similarity index 100% rename from src/agentex_sdk/types/agents/name_rpc_params.py rename to src/agentex/types/agents/name_rpc_params.py diff --git a/src/agentex_sdk/types/data_content.py b/src/agentex/types/data_content.py similarity index 100% rename from src/agentex_sdk/types/data_content.py rename to src/agentex/types/data_content.py diff --git a/src/agentex_sdk/types/data_content_param.py b/src/agentex/types/data_content_param.py similarity index 100% rename from src/agentex_sdk/types/data_content_param.py rename to src/agentex/types/data_content_param.py diff --git a/src/agentex_sdk/types/echo_send_params.py b/src/agentex/types/echo_send_params.py similarity index 100% rename from src/agentex_sdk/types/echo_send_params.py rename to src/agentex/types/echo_send_params.py diff --git a/src/agentex_sdk/types/event.py b/src/agentex/types/event.py similarity index 100% rename from src/agentex_sdk/types/event.py rename to src/agentex/types/event.py diff --git a/src/agentex_sdk/types/event_list_params.py b/src/agentex/types/event_list_params.py similarity index 100% rename from src/agentex_sdk/types/event_list_params.py rename to src/agentex/types/event_list_params.py diff --git a/src/agentex_sdk/types/event_list_response.py b/src/agentex/types/event_list_response.py similarity index 100% rename from src/agentex_sdk/types/event_list_response.py rename to src/agentex/types/event_list_response.py diff --git a/src/agentex_sdk/types/message_author.py b/src/agentex/types/message_author.py similarity index 100% rename from src/agentex_sdk/types/message_author.py rename to src/agentex/types/message_author.py diff --git a/src/agentex_sdk/types/message_create_params.py b/src/agentex/types/message_create_params.py similarity index 100% rename from src/agentex_sdk/types/message_create_params.py rename to src/agentex/types/message_create_params.py diff --git a/src/agentex_sdk/types/message_list_params.py b/src/agentex/types/message_list_params.py similarity index 100% rename from src/agentex_sdk/types/message_list_params.py rename to src/agentex/types/message_list_params.py diff --git a/src/agentex_sdk/types/message_list_response.py b/src/agentex/types/message_list_response.py similarity index 100% rename from src/agentex_sdk/types/message_list_response.py rename to src/agentex/types/message_list_response.py diff --git a/src/agentex_sdk/types/message_style.py b/src/agentex/types/message_style.py similarity index 100% rename from src/agentex_sdk/types/message_style.py rename to src/agentex/types/message_style.py diff --git a/src/agentex_sdk/types/message_update_params.py b/src/agentex/types/message_update_params.py similarity index 100% rename from src/agentex_sdk/types/message_update_params.py rename to src/agentex/types/message_update_params.py diff --git a/src/agentex_sdk/types/messages/__init__.py b/src/agentex/types/messages/__init__.py similarity index 100% rename from src/agentex_sdk/types/messages/__init__.py rename to src/agentex/types/messages/__init__.py diff --git a/src/agentex_sdk/types/messages/batch_create_params.py b/src/agentex/types/messages/batch_create_params.py similarity index 100% rename from src/agentex_sdk/types/messages/batch_create_params.py rename to src/agentex/types/messages/batch_create_params.py diff --git a/src/agentex_sdk/types/messages/batch_create_response.py b/src/agentex/types/messages/batch_create_response.py similarity index 100% rename from src/agentex_sdk/types/messages/batch_create_response.py rename to src/agentex/types/messages/batch_create_response.py diff --git a/src/agentex_sdk/types/messages/batch_update_params.py b/src/agentex/types/messages/batch_update_params.py similarity index 100% rename from src/agentex_sdk/types/messages/batch_update_params.py rename to src/agentex/types/messages/batch_update_params.py diff --git a/src/agentex_sdk/types/messages/batch_update_response.py b/src/agentex/types/messages/batch_update_response.py similarity index 100% rename from src/agentex_sdk/types/messages/batch_update_response.py rename to src/agentex/types/messages/batch_update_response.py diff --git a/src/agentex_sdk/types/send_event_request_param.py b/src/agentex/types/send_event_request_param.py similarity index 100% rename from src/agentex_sdk/types/send_event_request_param.py rename to src/agentex/types/send_event_request_param.py diff --git a/src/agentex_sdk/types/span.py b/src/agentex/types/span.py similarity index 100% rename from src/agentex_sdk/types/span.py rename to src/agentex/types/span.py diff --git a/src/agentex_sdk/types/span_create_params.py b/src/agentex/types/span_create_params.py similarity index 100% rename from src/agentex_sdk/types/span_create_params.py rename to src/agentex/types/span_create_params.py diff --git a/src/agentex_sdk/types/span_list_params.py b/src/agentex/types/span_list_params.py similarity index 100% rename from src/agentex_sdk/types/span_list_params.py rename to src/agentex/types/span_list_params.py diff --git a/src/agentex_sdk/types/span_list_response.py b/src/agentex/types/span_list_response.py similarity index 100% rename from src/agentex_sdk/types/span_list_response.py rename to src/agentex/types/span_list_response.py diff --git a/src/agentex_sdk/types/span_update_params.py b/src/agentex/types/span_update_params.py similarity index 100% rename from src/agentex_sdk/types/span_update_params.py rename to src/agentex/types/span_update_params.py diff --git a/src/agentex_sdk/types/state.py b/src/agentex/types/state.py similarity index 100% rename from src/agentex_sdk/types/state.py rename to src/agentex/types/state.py diff --git a/src/agentex_sdk/types/state_create_params.py b/src/agentex/types/state_create_params.py similarity index 100% rename from src/agentex_sdk/types/state_create_params.py rename to src/agentex/types/state_create_params.py diff --git a/src/agentex_sdk/types/state_list_params.py b/src/agentex/types/state_list_params.py similarity index 100% rename from src/agentex_sdk/types/state_list_params.py rename to src/agentex/types/state_list_params.py diff --git a/src/agentex_sdk/types/state_list_response.py b/src/agentex/types/state_list_response.py similarity index 100% rename from src/agentex_sdk/types/state_list_response.py rename to src/agentex/types/state_list_response.py diff --git a/src/agentex_sdk/types/state_update_params.py b/src/agentex/types/state_update_params.py similarity index 100% rename from src/agentex_sdk/types/state_update_params.py rename to src/agentex/types/state_update_params.py diff --git a/src/agentex_sdk/types/streaming_status.py b/src/agentex/types/streaming_status.py similarity index 100% rename from src/agentex_sdk/types/streaming_status.py rename to src/agentex/types/streaming_status.py diff --git a/src/agentex_sdk/types/task.py b/src/agentex/types/task.py similarity index 100% rename from src/agentex_sdk/types/task.py rename to src/agentex/types/task.py diff --git a/src/agentex_sdk/types/task_list_response.py b/src/agentex/types/task_list_response.py similarity index 100% rename from src/agentex_sdk/types/task_list_response.py rename to src/agentex/types/task_list_response.py diff --git a/src/agentex_sdk/types/task_message.py b/src/agentex/types/task_message.py similarity index 100% rename from src/agentex_sdk/types/task_message.py rename to src/agentex/types/task_message.py diff --git a/src/agentex_sdk/types/tasks/__init__.py b/src/agentex/types/tasks/__init__.py similarity index 100% rename from src/agentex_sdk/types/tasks/__init__.py rename to src/agentex/types/tasks/__init__.py diff --git a/src/agentex_sdk/types/text_content.py b/src/agentex/types/text_content.py similarity index 100% rename from src/agentex_sdk/types/text_content.py rename to src/agentex/types/text_content.py diff --git a/src/agentex_sdk/types/text_content_param.py b/src/agentex/types/text_content_param.py similarity index 100% rename from src/agentex_sdk/types/text_content_param.py rename to src/agentex/types/text_content_param.py diff --git a/src/agentex_sdk/types/tool_request_content.py b/src/agentex/types/tool_request_content.py similarity index 100% rename from src/agentex_sdk/types/tool_request_content.py rename to src/agentex/types/tool_request_content.py diff --git a/src/agentex_sdk/types/tool_request_content_param.py b/src/agentex/types/tool_request_content_param.py similarity index 100% rename from src/agentex_sdk/types/tool_request_content_param.py rename to src/agentex/types/tool_request_content_param.py diff --git a/src/agentex_sdk/types/tool_response_content.py b/src/agentex/types/tool_response_content.py similarity index 100% rename from src/agentex_sdk/types/tool_response_content.py rename to src/agentex/types/tool_response_content.py diff --git a/src/agentex_sdk/types/tool_response_content_param.py b/src/agentex/types/tool_response_content_param.py similarity index 100% rename from src/agentex_sdk/types/tool_response_content_param.py rename to src/agentex/types/tool_response_content_param.py diff --git a/src/agentex_sdk/types/tracker_list_params.py b/src/agentex/types/tracker_list_params.py similarity index 100% rename from src/agentex_sdk/types/tracker_list_params.py rename to src/agentex/types/tracker_list_params.py diff --git a/src/agentex_sdk/types/tracker_list_response.py b/src/agentex/types/tracker_list_response.py similarity index 100% rename from src/agentex_sdk/types/tracker_list_response.py rename to src/agentex/types/tracker_list_response.py diff --git a/src/agentex_sdk/types/tracker_update_params.py b/src/agentex/types/tracker_update_params.py similarity index 100% rename from src/agentex_sdk/types/tracker_update_params.py rename to src/agentex/types/tracker_update_params.py diff --git a/tests/api_resources/agents/test_name.py b/tests/api_resources/agents/test_name.py index ac850392..5b3d67dd 100644 --- a/tests/api_resources/agents/test_name.py +++ b/tests/api_resources/agents/test_name.py @@ -7,9 +7,9 @@ import pytest -from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from agentex import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type -from agentex_sdk.types import Agent +from agentex.types import Agent base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") diff --git a/tests/api_resources/messages/test_batch.py b/tests/api_resources/messages/test_batch.py index b999e8e9..eb4d99cb 100644 --- a/tests/api_resources/messages/test_batch.py +++ b/tests/api_resources/messages/test_batch.py @@ -7,12 +7,9 @@ import pytest -from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from agentex import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type -from agentex_sdk.types.messages import ( - BatchCreateResponse, - BatchUpdateResponse, -) +from agentex.types.messages import BatchCreateResponse, BatchUpdateResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") diff --git a/tests/api_resources/tasks/test_name.py b/tests/api_resources/tasks/test_name.py index 3d467559..084296a6 100644 --- a/tests/api_resources/tasks/test_name.py +++ b/tests/api_resources/tasks/test_name.py @@ -7,9 +7,9 @@ import pytest -from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from agentex import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type -from agentex_sdk.types import Task +from agentex.types import Task base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index 96e39991..be59c65d 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -7,9 +7,9 @@ import pytest -from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from agentex import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type -from agentex_sdk.types import Agent, AgentListResponse +from agentex.types import Agent, AgentListResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") diff --git a/tests/api_resources/test_client.py b/tests/api_resources/test_client.py index a9616d4a..7df05a88 100644 --- a/tests/api_resources/test_client.py +++ b/tests/api_resources/test_client.py @@ -7,7 +7,7 @@ import pytest -from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from agentex import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") diff --git a/tests/api_resources/test_echo.py b/tests/api_resources/test_echo.py index 5b841dc3..61f2c9c4 100644 --- a/tests/api_resources/test_echo.py +++ b/tests/api_resources/test_echo.py @@ -7,7 +7,7 @@ import pytest -from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from agentex import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") diff --git a/tests/api_resources/test_events.py b/tests/api_resources/test_events.py index eced991b..4543cd61 100644 --- a/tests/api_resources/test_events.py +++ b/tests/api_resources/test_events.py @@ -7,9 +7,9 @@ import pytest -from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from agentex import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type -from agentex_sdk.types import Event, EventListResponse +from agentex.types import Event, EventListResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py index 2a6a849c..9eee20e0 100644 --- a/tests/api_resources/test_messages.py +++ b/tests/api_resources/test_messages.py @@ -7,9 +7,9 @@ import pytest -from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from agentex import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type -from agentex_sdk.types import ( +from agentex.types import ( TaskMessage, MessageListResponse, ) diff --git a/tests/api_resources/test_spans.py b/tests/api_resources/test_spans.py index 7e748ccc..7032fec9 100644 --- a/tests/api_resources/test_spans.py +++ b/tests/api_resources/test_spans.py @@ -7,10 +7,10 @@ import pytest -from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from agentex import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type -from agentex_sdk.types import Span, SpanListResponse -from agentex_sdk._utils import parse_datetime +from agentex.types import Span, SpanListResponse +from agentex._utils import parse_datetime base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") diff --git a/tests/api_resources/test_states.py b/tests/api_resources/test_states.py index 83e09dfd..22bd9f01 100644 --- a/tests/api_resources/test_states.py +++ b/tests/api_resources/test_states.py @@ -7,9 +7,9 @@ import pytest -from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from agentex import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type -from agentex_sdk.types import State, StateListResponse +from agentex.types import State, StateListResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") diff --git a/tests/api_resources/test_tasks.py b/tests/api_resources/test_tasks.py index 4d84c07e..048f8a03 100644 --- a/tests/api_resources/test_tasks.py +++ b/tests/api_resources/test_tasks.py @@ -7,9 +7,9 @@ import pytest -from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from agentex import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type -from agentex_sdk.types import Task, TaskListResponse +from agentex.types import Task, TaskListResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") diff --git a/tests/api_resources/test_tracker.py b/tests/api_resources/test_tracker.py index 8c8ffba5..c93c4e88 100644 --- a/tests/api_resources/test_tracker.py +++ b/tests/api_resources/test_tracker.py @@ -7,9 +7,9 @@ import pytest -from agentex_sdk import AgentexSDK, AsyncAgentexSDK +from agentex import AgentexSDK, AsyncAgentexSDK from tests.utils import assert_matches_type -from agentex_sdk.types import AgentTaskTracker, TrackerListResponse +from agentex.types import AgentTaskTracker, TrackerListResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") diff --git a/tests/conftest.py b/tests/conftest.py index c65ffa83..5fddcb23 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -10,15 +10,15 @@ import pytest from pytest_asyncio import is_async_test -from agentex_sdk import AgentexSDK, AsyncAgentexSDK, DefaultAioHttpClient -from agentex_sdk._utils import is_dict +from agentex import AgentexSDK, AsyncAgentexSDK, DefaultAioHttpClient +from agentex._utils import is_dict if TYPE_CHECKING: from _pytest.fixtures import FixtureRequest # pyright: ignore[reportPrivateImportUsage] pytest.register_assert_rewrite("tests.utils") -logging.getLogger("agentex_sdk").setLevel(logging.DEBUG) +logging.getLogger("agentex").setLevel(logging.DEBUG) # automatically add `pytest.mark.asyncio()` to all of our async tests diff --git a/tests/test_client.py b/tests/test_client.py index 26e8f818..d6a03e84 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -21,11 +21,11 @@ from respx import MockRouter from pydantic import ValidationError -from agentex_sdk import AgentexSDK, AsyncAgentexSDK, APIResponseValidationError -from agentex_sdk._types import Omit -from agentex_sdk._models import BaseModel, FinalRequestOptions -from agentex_sdk._exceptions import APIStatusError, APITimeoutError, APIResponseValidationError -from agentex_sdk._base_client import ( +from agentex import AgentexSDK, AsyncAgentexSDK, APIResponseValidationError +from agentex._types import Omit +from agentex._models import BaseModel, FinalRequestOptions +from agentex._exceptions import APIStatusError, APITimeoutError, APIResponseValidationError +from agentex._base_client import ( DEFAULT_TIMEOUT, HTTPX_DEFAULT_TIMEOUT, BaseClient, @@ -232,10 +232,10 @@ def add_leak(leaks: list[tracemalloc.StatisticDiff], diff: tracemalloc.Statistic # to_raw_response_wrapper leaks through the @functools.wraps() decorator. # # removing the decorator fixes the leak for reasons we don't understand. - "agentex_sdk/_legacy_response.py", - "agentex_sdk/_response.py", + "agentex/_legacy_response.py", + "agentex/_response.py", # pydantic.BaseModel.model_dump || pydantic.BaseModel.dict leak memory for some reason. - "agentex_sdk/_compat.py", + "agentex/_compat.py", # Standard library leaks we don't care about. "/logging/__init__.py", ] @@ -728,7 +728,7 @@ def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str calculated = client._calculate_retry_timeout(remaining_retries, options, headers) assert calculated == pytest.approx(timeout, 0.5 * 0.875) # pyright: ignore[reportUnknownMemberType] - @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter, client: AgentexSDK) -> None: respx_mock.post("/echo").mock(side_effect=httpx.TimeoutException("Test timeout error")) @@ -738,7 +738,7 @@ def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter, clien assert _get_open_connections(self.client) == 0 - @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, client: AgentexSDK) -> None: respx_mock.post("/echo").mock(return_value=httpx.Response(500)) @@ -748,7 +748,7 @@ def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, client assert _get_open_connections(self.client) == 0 @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) - @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) @pytest.mark.parametrize("failure_mode", ["status", "exception"]) def test_retries_taken( @@ -779,7 +779,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) - @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) def test_omit_retry_count_header( self, client: AgentexSDK, failures_before_success: int, respx_mock: MockRouter @@ -804,7 +804,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: assert len(response.http_request.headers.get_list("x-stainless-retry-count")) == 0 @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) - @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) def test_overwrite_retry_count_header( self, client: AgentexSDK, failures_before_success: int, respx_mock: MockRouter @@ -1054,10 +1054,10 @@ def add_leak(leaks: list[tracemalloc.StatisticDiff], diff: tracemalloc.Statistic # to_raw_response_wrapper leaks through the @functools.wraps() decorator. # # removing the decorator fixes the leak for reasons we don't understand. - "agentex_sdk/_legacy_response.py", - "agentex_sdk/_response.py", + "agentex/_legacy_response.py", + "agentex/_response.py", # pydantic.BaseModel.model_dump || pydantic.BaseModel.dict leak memory for some reason. - "agentex_sdk/_compat.py", + "agentex/_compat.py", # Standard library leaks we don't care about. "/logging/__init__.py", ] @@ -1556,7 +1556,7 @@ async def test_parse_retry_after_header(self, remaining_retries: int, retry_afte calculated = client._calculate_retry_timeout(remaining_retries, options, headers) assert calculated == pytest.approx(timeout, 0.5 * 0.875) # pyright: ignore[reportUnknownMemberType] - @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) async def test_retrying_timeout_errors_doesnt_leak( self, respx_mock: MockRouter, async_client: AsyncAgentexSDK @@ -1568,7 +1568,7 @@ async def test_retrying_timeout_errors_doesnt_leak( assert _get_open_connections(self.client) == 0 - @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) async def test_retrying_status_errors_doesnt_leak( self, respx_mock: MockRouter, async_client: AsyncAgentexSDK @@ -1580,7 +1580,7 @@ async def test_retrying_status_errors_doesnt_leak( assert _get_open_connections(self.client) == 0 @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) - @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) @pytest.mark.asyncio @pytest.mark.parametrize("failure_mode", ["status", "exception"]) @@ -1612,7 +1612,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) - @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) @pytest.mark.asyncio async def test_omit_retry_count_header( @@ -1638,7 +1638,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: assert len(response.http_request.headers.get_list("x-stainless-retry-count")) == 0 @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) - @mock.patch("agentex_sdk._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) + @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) @pytest.mark.asyncio async def test_overwrite_retry_count_header( @@ -1674,8 +1674,8 @@ def test_get_platform(self) -> None: import nest_asyncio import threading - from agentex_sdk._utils import asyncify - from agentex_sdk._base_client import get_platform + from agentex._utils import asyncify + from agentex._base_client import get_platform async def test_main() -> None: result = await asyncify(get_platform)() diff --git a/tests/test_deepcopy.py b/tests/test_deepcopy.py index 629bec1f..3fc74ccb 100644 --- a/tests/test_deepcopy.py +++ b/tests/test_deepcopy.py @@ -1,4 +1,4 @@ -from agentex_sdk._utils import deepcopy_minimal +from agentex._utils import deepcopy_minimal def assert_different_identities(obj1: object, obj2: object) -> None: diff --git a/tests/test_extract_files.py b/tests/test_extract_files.py index c01fa4ae..43b12be2 100644 --- a/tests/test_extract_files.py +++ b/tests/test_extract_files.py @@ -4,8 +4,8 @@ import pytest -from agentex_sdk._types import FileTypes -from agentex_sdk._utils import extract_files +from agentex._types import FileTypes +from agentex._utils import extract_files def test_removes_files_from_input() -> None: diff --git a/tests/test_files.py b/tests/test_files.py index f32d4061..e88f71f4 100644 --- a/tests/test_files.py +++ b/tests/test_files.py @@ -4,7 +4,7 @@ import pytest from dirty_equals import IsDict, IsList, IsBytes, IsTuple -from agentex_sdk._files import to_httpx_files, async_to_httpx_files +from agentex._files import to_httpx_files, async_to_httpx_files readme_path = Path(__file__).parent.parent.joinpath("README.md") diff --git a/tests/test_models.py b/tests/test_models.py index 96e9e1c4..a8867d60 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -7,9 +7,9 @@ import pydantic from pydantic import Field -from agentex_sdk._utils import PropertyInfo -from agentex_sdk._compat import PYDANTIC_V2, parse_obj, model_dump, model_json -from agentex_sdk._models import BaseModel, construct_type +from agentex._utils import PropertyInfo +from agentex._compat import PYDANTIC_V2, parse_obj, model_dump, model_json +from agentex._models import BaseModel, construct_type class BasicModel(BaseModel): diff --git a/tests/test_qs.py b/tests/test_qs.py index 998f6022..a938eb26 100644 --- a/tests/test_qs.py +++ b/tests/test_qs.py @@ -4,7 +4,7 @@ import pytest -from agentex_sdk._qs import Querystring, stringify +from agentex._qs import Querystring, stringify def test_empty() -> None: diff --git a/tests/test_required_args.py b/tests/test_required_args.py index 16023cc7..f507b1c0 100644 --- a/tests/test_required_args.py +++ b/tests/test_required_args.py @@ -2,7 +2,7 @@ import pytest -from agentex_sdk._utils import required_args +from agentex._utils import required_args def test_too_many_positional_params() -> None: diff --git a/tests/test_response.py b/tests/test_response.py index fb7b5b8c..b8608700 100644 --- a/tests/test_response.py +++ b/tests/test_response.py @@ -6,8 +6,8 @@ import pytest import pydantic -from agentex_sdk import BaseModel, AgentexSDK, AsyncAgentexSDK -from agentex_sdk._response import ( +from agentex import BaseModel, AgentexSDK, AsyncAgentexSDK +from agentex._response import ( APIResponse, BaseAPIResponse, AsyncAPIResponse, @@ -15,8 +15,8 @@ AsyncBinaryAPIResponse, extract_response_type, ) -from agentex_sdk._streaming import Stream -from agentex_sdk._base_client import FinalRequestOptions +from agentex._streaming import Stream +from agentex._base_client import FinalRequestOptions class ConcreteBaseAPIResponse(APIResponse[bytes]): ... @@ -37,7 +37,7 @@ def test_extract_response_type_direct_classes() -> None: def test_extract_response_type_direct_class_missing_type_arg() -> None: with pytest.raises( RuntimeError, - match="Expected type to have a type argument at index 0 but it did not", + match="Expected type to have a type argument at index 0 but it did not", ): extract_response_type(AsyncAPIResponse) @@ -68,7 +68,7 @@ def test_response_parse_mismatched_basemodel(client: AgentexSDK) -> None: with pytest.raises( TypeError, - match="Pydantic models must subclass our base model type, e.g. `from agentex_sdk import BaseModel`", + match="Pydantic models must subclass our base model type, e.g. `from agentex import BaseModel`", ): response.parse(to=PydanticModel) @@ -86,7 +86,7 @@ async def test_async_response_parse_mismatched_basemodel(async_client: AsyncAgen with pytest.raises( TypeError, - match="Pydantic models must subclass our base model type, e.g. `from agentex_sdk import BaseModel`", + match="Pydantic models must subclass our base model type, e.g. `from agentex import BaseModel`", ): await response.parse(to=PydanticModel) diff --git a/tests/test_streaming.py b/tests/test_streaming.py index 40d96b05..aa5b8003 100644 --- a/tests/test_streaming.py +++ b/tests/test_streaming.py @@ -5,8 +5,8 @@ import httpx import pytest -from agentex_sdk import AgentexSDK, AsyncAgentexSDK -from agentex_sdk._streaming import Stream, AsyncStream, ServerSentEvent +from agentex import AgentexSDK, AsyncAgentexSDK +from agentex._streaming import Stream, AsyncStream, ServerSentEvent @pytest.mark.asyncio diff --git a/tests/test_transform.py b/tests/test_transform.py index 69920f1c..606a1788 100644 --- a/tests/test_transform.py +++ b/tests/test_transform.py @@ -8,15 +8,15 @@ import pytest -from agentex_sdk._types import NOT_GIVEN, Base64FileInput -from agentex_sdk._utils import ( +from agentex._types import NOT_GIVEN, Base64FileInput +from agentex._utils import ( PropertyInfo, transform as _transform, parse_datetime, async_transform as _async_transform, ) -from agentex_sdk._compat import PYDANTIC_V2 -from agentex_sdk._models import BaseModel +from agentex._compat import PYDANTIC_V2 +from agentex._models import BaseModel _T = TypeVar("_T") diff --git a/tests/test_utils/test_proxy.py b/tests/test_utils/test_proxy.py index 7e7d0282..21a15f98 100644 --- a/tests/test_utils/test_proxy.py +++ b/tests/test_utils/test_proxy.py @@ -2,7 +2,7 @@ from typing import Any from typing_extensions import override -from agentex_sdk._utils import LazyProxy +from agentex._utils import LazyProxy class RecursiveLazyProxy(LazyProxy[Any]): diff --git a/tests/test_utils/test_typing.py b/tests/test_utils/test_typing.py index 1b29124b..cd4f1800 100644 --- a/tests/test_utils/test_typing.py +++ b/tests/test_utils/test_typing.py @@ -2,7 +2,7 @@ from typing import Generic, TypeVar, cast -from agentex_sdk._utils import extract_type_var_from_base +from agentex._utils import extract_type_var_from_base _T = TypeVar("_T") _T2 = TypeVar("_T2") diff --git a/tests/utils.py b/tests/utils.py index d76528f0..f1d43e95 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -8,8 +8,8 @@ from datetime import date, datetime from typing_extensions import Literal, get_args, get_origin, assert_type -from agentex_sdk._types import Omit, NoneType -from agentex_sdk._utils import ( +from agentex._types import Omit, NoneType +from agentex._utils import ( is_dict, is_list, is_list_type, @@ -18,8 +18,8 @@ is_annotated_type, is_type_alias_type, ) -from agentex_sdk._compat import PYDANTIC_V2, field_outer_type, get_model_fields -from agentex_sdk._models import BaseModel +from agentex._compat import PYDANTIC_V2, field_outer_type, get_model_fields +from agentex._models import BaseModel BaseModelT = TypeVar("BaseModelT", bound=BaseModel) From feb19c19ec9b43779171e2ba7593f24ed314b600 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 17 Jul 2025 23:54:19 +0000 Subject: [PATCH 0012/1108] codegen metadata --- .stats.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.stats.yml b/.stats.yml index 11b5c649..b29d5b4c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 36 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-e8ce15a00ebbfb8be199c0172a95616741cb872a8d346bd039cdde45153ec79c.yml openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 -config_hash: 00be5715c3420ef99bce1df3a24947d1 +config_hash: d06acc118b96114bcae04b43a5d384a8 From a462222d6db8f22642abfdfeeaae248858be0a34 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 17 Jul 2025 23:54:50 +0000 Subject: [PATCH 0013/1108] feat(api): manual updates --- .stats.yml | 2 +- LICENSE | 2 +- README.md | 50 +++--- SECURITY.md | 2 +- api.md | 2 +- pyproject.toml | 4 +- src/agentex/__init__.py | 20 +-- src/agentex/_client.py | 63 ++++---- src/agentex/_exceptions.py | 4 +- src/agentex/_resource.py | 10 +- src/agentex/_response.py | 4 +- src/agentex/_streaming.py | 6 +- src/agentex/_utils/_logs.py | 2 +- tests/api_resources/agents/test_name.py | 54 +++---- tests/api_resources/messages/test_batch.py | 26 ++-- tests/api_resources/tasks/test_name.py | 50 +++--- tests/api_resources/test_agents.py | 70 ++++----- tests/api_resources/test_client.py | 14 +- tests/api_resources/test_echo.py | 14 +- tests/api_resources/test_events.py | 34 ++--- tests/api_resources/test_messages.py | 70 ++++----- tests/api_resources/test_spans.py | 70 ++++----- tests/api_resources/test_states.py | 78 +++++----- tests/api_resources/test_tasks.py | 62 ++++---- tests/api_resources/test_tracker.py | 54 +++---- tests/conftest.py | 10 +- tests/test_client.py | 168 ++++++++++----------- tests/test_response.py | 26 ++-- tests/test_streaming.py | 32 ++-- 29 files changed, 485 insertions(+), 518 deletions(-) diff --git a/.stats.yml b/.stats.yml index b29d5b4c..633be9e4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 36 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-e8ce15a00ebbfb8be199c0172a95616741cb872a8d346bd039cdde45153ec79c.yml openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 -config_hash: d06acc118b96114bcae04b43a5d384a8 +config_hash: 34ee931ef475bb5c3697d8a920a13f22 diff --git a/LICENSE b/LICENSE index 50c29288..d2ee12de 100644 --- a/LICENSE +++ b/LICENSE @@ -186,7 +186,7 @@ same "printed page" as the copyright notice for easier identification within third-party archives. - Copyright 2025 Agentex SDK + Copyright 2025 Agentex Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/README.md b/README.md index 852a5a7b..942f8a8d 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,9 @@ -# Agentex SDK Python API library +# Agentex Python API library [![PyPI version](https://img.shields.io/pypi/v/agentex.svg?label=pypi%20(stable))](https://pypi.org/project/agentex/) -The Agentex SDK Python library provides convenient access to the Agentex SDK REST API from any Python 3.8+ +The Agentex Python library provides convenient access to the Agentex REST API from any Python 3.8+ application. The library includes type definitions for all request params and response fields, and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx). @@ -29,9 +29,9 @@ The full API of this library can be found in [api.md](api.md). ```python import os -from agentex import AgentexSDK +from agentex import Agentex -client = AgentexSDK( +client = Agentex( api_key=os.environ.get("AGENTEX_SDK_API_KEY"), # This is the default and can be omitted ) @@ -47,14 +47,14 @@ so that your API Key is not stored in source control. ## Async usage -Simply import `AsyncAgentexSDK` instead of `AgentexSDK` and use `await` with each API call: +Simply import `AsyncAgentex` instead of `Agentex` and use `await` with each API call: ```python import os import asyncio -from agentex import AsyncAgentexSDK +from agentex import AsyncAgentex -client = AsyncAgentexSDK( +client = AsyncAgentex( api_key=os.environ.get("AGENTEX_SDK_API_KEY"), # This is the default and can be omitted ) @@ -86,11 +86,11 @@ Then you can enable it by instantiating the client with `http_client=DefaultAioH ```python import asyncio from agentex import DefaultAioHttpClient -from agentex import AsyncAgentexSDK +from agentex import AsyncAgentex async def main() -> None: - async with AsyncAgentexSDK( + async with AsyncAgentex( api_key="My API Key", http_client=DefaultAioHttpClient(), ) as client: @@ -122,9 +122,9 @@ All errors inherit from `agentex.APIError`. ```python import agentex -from agentex import AgentexSDK +from agentex import Agentex -client = AgentexSDK() +client = Agentex() try: client.echo.send( @@ -163,10 +163,10 @@ Connection errors (for example, due to a network connectivity problem), 408 Requ You can use the `max_retries` option to configure or disable retry settings: ```python -from agentex import AgentexSDK +from agentex import Agentex # Configure the default for all requests: -client = AgentexSDK( +client = Agentex( # default is 2 max_retries=0, ) @@ -183,16 +183,16 @@ By default requests time out after 1 minute. You can configure this with a `time which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/timeouts/#fine-tuning-the-configuration) object: ```python -from agentex import AgentexSDK +from agentex import Agentex # Configure the default for all requests: -client = AgentexSDK( +client = Agentex( # 20 seconds (default is 1 minute) timeout=20.0, ) # More granular control: -client = AgentexSDK( +client = Agentex( timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0), ) @@ -212,10 +212,10 @@ Note that requests that time out are [retried twice by default](#retries). We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module. -You can enable logging by setting the environment variable `AGENTEX_SDK_LOG` to `info`. +You can enable logging by setting the environment variable `AGENTEX_LOG` to `info`. ```shell -$ export AGENTEX_SDK_LOG=info +$ export AGENTEX_LOG=info ``` Or to `debug` for more verbose logging. @@ -237,9 +237,9 @@ if response.my_field is None: The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g., ```py -from agentex import AgentexSDK +from agentex import Agentex -client = AgentexSDK() +client = Agentex() response = client.echo.with_raw_response.send( message="message", ) @@ -315,10 +315,10 @@ You can directly override the [httpx client](https://www.python-httpx.org/api/#c ```python import httpx -from agentex import AgentexSDK, DefaultHttpxClient +from agentex import Agentex, DefaultHttpxClient -client = AgentexSDK( - # Or use the `AGENTEX_SDK_BASE_URL` env var +client = Agentex( + # Or use the `AGENTEX_BASE_URL` env var base_url="http://my.test.server.example.com:8083", http_client=DefaultHttpxClient( proxy="http://my.test.proxy.example.com", @@ -338,9 +338,9 @@ client.with_options(http_client=DefaultHttpxClient(...)) By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting. ```py -from agentex import AgentexSDK +from agentex import Agentex -with AgentexSDK() as client: +with Agentex() as client: # make requests here ... diff --git a/SECURITY.md b/SECURITY.md index f4291cc3..d7ff1dab 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -16,7 +16,7 @@ before making any information public. ## Reporting Non-SDK Related Security Issues If you encounter security issues that are not directly related to SDKs but pertain to the services -or products provided by Agentex SDK, please follow the respective company's security reporting guidelines. +or products provided by Agentex, please follow the respective company's security reporting guidelines. --- diff --git a/api.md b/api.md index aab9f936..693e4ae5 100644 --- a/api.md +++ b/api.md @@ -1,4 +1,4 @@ -# AgentexSDK +# Agentex Methods: diff --git a/pyproject.toml b/pyproject.toml index 608ee777..dc089bdd 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,11 +1,11 @@ [project] name = "agentex" version = "0.0.1-alpha.0" -description = "The official Python library for the agentex-sdk API" +description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" authors = [ -{ name = "Agentex SDK", email = "" }, +{ name = "Agentex", email = "" }, ] dependencies = [ "httpx>=0.23.0, <1", diff --git a/src/agentex/__init__.py b/src/agentex/__init__.py index 7aaf8252..891c638e 100644 --- a/src/agentex/__init__.py +++ b/src/agentex/__init__.py @@ -5,28 +5,18 @@ from . import types from ._types import NOT_GIVEN, Omit, NoneType, NotGiven, Transport, ProxiesTypes from ._utils import file_from_path -from ._client import ( - Client, - Stream, - Timeout, - Transport, - AgentexSDK, - AsyncClient, - AsyncStream, - RequestOptions, - AsyncAgentexSDK, -) +from ._client import Client, Stream, Agentex, Timeout, Transport, AsyncClient, AsyncStream, AsyncAgentex, RequestOptions from ._models import BaseModel from ._version import __title__, __version__ from ._response import APIResponse as APIResponse, AsyncAPIResponse as AsyncAPIResponse from ._constants import DEFAULT_TIMEOUT, DEFAULT_MAX_RETRIES, DEFAULT_CONNECTION_LIMITS from ._exceptions import ( APIError, + AgentexError, ConflictError, NotFoundError, APIStatusError, RateLimitError, - AgentexSDKError, APITimeoutError, BadRequestError, APIConnectionError, @@ -49,7 +39,7 @@ "NotGiven", "NOT_GIVEN", "Omit", - "AgentexSDKError", + "AgentexError", "APIError", "APIStatusError", "APITimeoutError", @@ -69,8 +59,8 @@ "AsyncClient", "Stream", "AsyncStream", - "AgentexSDK", - "AsyncAgentexSDK", + "Agentex", + "AsyncAgentex", "file_from_path", "BaseModel", "DEFAULT_TIMEOUT", diff --git a/src/agentex/_client.py b/src/agentex/_client.py index d992c5f8..ee34e357 100644 --- a/src/agentex/_client.py +++ b/src/agentex/_client.py @@ -43,19 +43,10 @@ from .resources.agents import agents from .resources.messages import messages -__all__ = [ - "Timeout", - "Transport", - "ProxiesTypes", - "RequestOptions", - "AgentexSDK", - "AsyncAgentexSDK", - "Client", - "AsyncClient", -] - - -class AgentexSDK(SyncAPIClient): +__all__ = ["Timeout", "Transport", "ProxiesTypes", "RequestOptions", "Agentex", "AsyncAgentex", "Client", "AsyncClient"] + + +class Agentex(SyncAPIClient): echo: echo.EchoResource agents: agents.AgentsResource tasks: tasks.TasksResource @@ -64,8 +55,8 @@ class AgentexSDK(SyncAPIClient): states: states.StatesResource events: events.EventsResource tracker: tracker.TrackerResource - with_raw_response: AgentexSDKWithRawResponse - with_streaming_response: AgentexSDKWithStreamedResponse + with_raw_response: AgentexWithRawResponse + with_streaming_response: AgentexWithStreamedResponse # client options api_key: str | None @@ -93,7 +84,7 @@ def __init__( # part of our public interface in the future. _strict_response_validation: bool = False, ) -> None: - """Construct a new synchronous AgentexSDK client instance. + """Construct a new synchronous Agentex client instance. This automatically infers the `api_key` argument from the `AGENTEX_SDK_API_KEY` environment variable if it is not provided. """ @@ -102,7 +93,7 @@ def __init__( self.api_key = api_key if base_url is None: - base_url = os.environ.get("AGENTEX_SDK_BASE_URL") + base_url = os.environ.get("AGENTEX_BASE_URL") if base_url is None: base_url = f"https://api.example.com" @@ -125,8 +116,8 @@ def __init__( self.states = states.StatesResource(self) self.events = events.EventsResource(self) self.tracker = tracker.TrackerResource(self) - self.with_raw_response = AgentexSDKWithRawResponse(self) - self.with_streaming_response = AgentexSDKWithStreamedResponse(self) + self.with_raw_response = AgentexWithRawResponse(self) + self.with_streaming_response = AgentexWithStreamedResponse(self) @property @override @@ -265,7 +256,7 @@ def _make_status_error( return APIStatusError(err_msg, response=response, body=body) -class AsyncAgentexSDK(AsyncAPIClient): +class AsyncAgentex(AsyncAPIClient): echo: echo.AsyncEchoResource agents: agents.AsyncAgentsResource tasks: tasks.AsyncTasksResource @@ -274,8 +265,8 @@ class AsyncAgentexSDK(AsyncAPIClient): states: states.AsyncStatesResource events: events.AsyncEventsResource tracker: tracker.AsyncTrackerResource - with_raw_response: AsyncAgentexSDKWithRawResponse - with_streaming_response: AsyncAgentexSDKWithStreamedResponse + with_raw_response: AsyncAgentexWithRawResponse + with_streaming_response: AsyncAgentexWithStreamedResponse # client options api_key: str | None @@ -303,7 +294,7 @@ def __init__( # part of our public interface in the future. _strict_response_validation: bool = False, ) -> None: - """Construct a new async AsyncAgentexSDK client instance. + """Construct a new async AsyncAgentex client instance. This automatically infers the `api_key` argument from the `AGENTEX_SDK_API_KEY` environment variable if it is not provided. """ @@ -312,7 +303,7 @@ def __init__( self.api_key = api_key if base_url is None: - base_url = os.environ.get("AGENTEX_SDK_BASE_URL") + base_url = os.environ.get("AGENTEX_BASE_URL") if base_url is None: base_url = f"https://api.example.com" @@ -335,8 +326,8 @@ def __init__( self.states = states.AsyncStatesResource(self) self.events = events.AsyncEventsResource(self) self.tracker = tracker.AsyncTrackerResource(self) - self.with_raw_response = AsyncAgentexSDKWithRawResponse(self) - self.with_streaming_response = AsyncAgentexSDKWithStreamedResponse(self) + self.with_raw_response = AsyncAgentexWithRawResponse(self) + self.with_streaming_response = AsyncAgentexWithStreamedResponse(self) @property @override @@ -475,8 +466,8 @@ def _make_status_error( return APIStatusError(err_msg, response=response, body=body) -class AgentexSDKWithRawResponse: - def __init__(self, client: AgentexSDK) -> None: +class AgentexWithRawResponse: + def __init__(self, client: Agentex) -> None: self.echo = echo.EchoResourceWithRawResponse(client.echo) self.agents = agents.AgentsResourceWithRawResponse(client.agents) self.tasks = tasks.TasksResourceWithRawResponse(client.tasks) @@ -491,8 +482,8 @@ def __init__(self, client: AgentexSDK) -> None: ) -class AsyncAgentexSDKWithRawResponse: - def __init__(self, client: AsyncAgentexSDK) -> None: +class AsyncAgentexWithRawResponse: + def __init__(self, client: AsyncAgentex) -> None: self.echo = echo.AsyncEchoResourceWithRawResponse(client.echo) self.agents = agents.AsyncAgentsResourceWithRawResponse(client.agents) self.tasks = tasks.AsyncTasksResourceWithRawResponse(client.tasks) @@ -507,8 +498,8 @@ def __init__(self, client: AsyncAgentexSDK) -> None: ) -class AgentexSDKWithStreamedResponse: - def __init__(self, client: AgentexSDK) -> None: +class AgentexWithStreamedResponse: + def __init__(self, client: Agentex) -> None: self.echo = echo.EchoResourceWithStreamingResponse(client.echo) self.agents = agents.AgentsResourceWithStreamingResponse(client.agents) self.tasks = tasks.TasksResourceWithStreamingResponse(client.tasks) @@ -523,8 +514,8 @@ def __init__(self, client: AgentexSDK) -> None: ) -class AsyncAgentexSDKWithStreamedResponse: - def __init__(self, client: AsyncAgentexSDK) -> None: +class AsyncAgentexWithStreamedResponse: + def __init__(self, client: AsyncAgentex) -> None: self.echo = echo.AsyncEchoResourceWithStreamingResponse(client.echo) self.agents = agents.AsyncAgentsResourceWithStreamingResponse(client.agents) self.tasks = tasks.AsyncTasksResourceWithStreamingResponse(client.tasks) @@ -539,6 +530,6 @@ def __init__(self, client: AsyncAgentexSDK) -> None: ) -Client = AgentexSDK +Client = Agentex -AsyncClient = AsyncAgentexSDK +AsyncClient = AsyncAgentex diff --git a/src/agentex/_exceptions.py b/src/agentex/_exceptions.py index bc245781..8f26c82b 100644 --- a/src/agentex/_exceptions.py +++ b/src/agentex/_exceptions.py @@ -18,11 +18,11 @@ ] -class AgentexSDKError(Exception): +class AgentexError(Exception): pass -class APIError(AgentexSDKError): +class APIError(AgentexError): message: str request: httpx.Request diff --git a/src/agentex/_resource.py b/src/agentex/_resource.py index cdad1ec0..246bd65d 100644 --- a/src/agentex/_resource.py +++ b/src/agentex/_resource.py @@ -8,13 +8,13 @@ import anyio if TYPE_CHECKING: - from ._client import AgentexSDK, AsyncAgentexSDK + from ._client import Agentex, AsyncAgentex class SyncAPIResource: - _client: AgentexSDK + _client: Agentex - def __init__(self, client: AgentexSDK) -> None: + def __init__(self, client: Agentex) -> None: self._client = client self._get = client.get self._post = client.post @@ -28,9 +28,9 @@ def _sleep(self, seconds: float) -> None: class AsyncAPIResource: - _client: AsyncAgentexSDK + _client: AsyncAgentex - def __init__(self, client: AsyncAgentexSDK) -> None: + def __init__(self, client: AsyncAgentex) -> None: self._client = client self._get = client.get self._post = client.post diff --git a/src/agentex/_response.py b/src/agentex/_response.py index 760047a9..be9bfbc3 100644 --- a/src/agentex/_response.py +++ b/src/agentex/_response.py @@ -29,7 +29,7 @@ from ._models import BaseModel, is_basemodel from ._constants import RAW_RESPONSE_HEADER, OVERRIDE_CAST_TO_HEADER from ._streaming import Stream, AsyncStream, is_stream_class_type, extract_stream_chunk_type -from ._exceptions import AgentexSDKError, APIResponseValidationError +from ._exceptions import AgentexError, APIResponseValidationError if TYPE_CHECKING: from ._models import FinalRequestOptions @@ -560,7 +560,7 @@ def __init__(self) -> None: ) -class StreamAlreadyConsumed(AgentexSDKError): +class StreamAlreadyConsumed(AgentexError): """ Attempted to read or stream content, but the content has already been streamed. diff --git a/src/agentex/_streaming.py b/src/agentex/_streaming.py index d44f59f6..cdcb3280 100644 --- a/src/agentex/_streaming.py +++ b/src/agentex/_streaming.py @@ -12,7 +12,7 @@ from ._utils import extract_type_var_from_base if TYPE_CHECKING: - from ._client import AgentexSDK, AsyncAgentexSDK + from ._client import Agentex, AsyncAgentex _T = TypeVar("_T") @@ -30,7 +30,7 @@ def __init__( *, cast_to: type[_T], response: httpx.Response, - client: AgentexSDK, + client: Agentex, ) -> None: self.response = response self._cast_to = cast_to @@ -93,7 +93,7 @@ def __init__( *, cast_to: type[_T], response: httpx.Response, - client: AsyncAgentexSDK, + client: AsyncAgentex, ) -> None: self.response = response self._cast_to = cast_to diff --git a/src/agentex/_utils/_logs.py b/src/agentex/_utils/_logs.py index f24bd049..ecfc8eeb 100644 --- a/src/agentex/_utils/_logs.py +++ b/src/agentex/_utils/_logs.py @@ -14,7 +14,7 @@ def _basic_config() -> None: def setup_logging() -> None: - env = os.environ.get("AGENTEX_SDK_LOG") + env = os.environ.get("AGENTEX_LOG") if env == "debug": _basic_config() logger.setLevel(logging.DEBUG) diff --git a/tests/api_resources/agents/test_name.py b/tests/api_resources/agents/test_name.py index 5b3d67dd..a16fe447 100644 --- a/tests/api_resources/agents/test_name.py +++ b/tests/api_resources/agents/test_name.py @@ -7,7 +7,7 @@ import pytest -from agentex import AgentexSDK, AsyncAgentexSDK +from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type from agentex.types import Agent @@ -19,7 +19,7 @@ class TestName: @pytest.mark.skip() @parametrize - def test_method_retrieve(self, client: AgentexSDK) -> None: + def test_method_retrieve(self, client: Agentex) -> None: name = client.agents.name.retrieve( "agent_name", ) @@ -27,7 +27,7 @@ def test_method_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.agents.name.with_raw_response.retrieve( "agent_name", ) @@ -39,7 +39,7 @@ def test_raw_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.agents.name.with_streaming_response.retrieve( "agent_name", ) as response: @@ -53,7 +53,7 @@ def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_retrieve(self, client: AgentexSDK) -> None: + def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): client.agents.name.with_raw_response.retrieve( "", @@ -61,7 +61,7 @@ def test_path_params_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_delete(self, client: AgentexSDK) -> None: + def test_method_delete(self, client: Agentex) -> None: name = client.agents.name.delete( "agent_name", ) @@ -69,7 +69,7 @@ def test_method_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_delete(self, client: AgentexSDK) -> None: + def test_raw_response_delete(self, client: Agentex) -> None: response = client.agents.name.with_raw_response.delete( "agent_name", ) @@ -81,7 +81,7 @@ def test_raw_response_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_delete(self, client: AgentexSDK) -> None: + def test_streaming_response_delete(self, client: Agentex) -> None: with client.agents.name.with_streaming_response.delete( "agent_name", ) as response: @@ -95,7 +95,7 @@ def test_streaming_response_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_delete(self, client: AgentexSDK) -> None: + def test_path_params_delete(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): client.agents.name.with_raw_response.delete( "", @@ -103,7 +103,7 @@ def test_path_params_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_rpc(self, client: AgentexSDK) -> None: + def test_method_rpc(self, client: Agentex) -> None: name = client.agents.name.rpc( agent_name="agent_name", method="event/send", @@ -113,7 +113,7 @@ def test_method_rpc(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_rpc_with_all_params(self, client: AgentexSDK) -> None: + def test_method_rpc_with_all_params(self, client: Agentex) -> None: name = client.agents.name.rpc( agent_name="agent_name", method="event/send", @@ -128,7 +128,7 @@ def test_method_rpc_with_all_params(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_rpc(self, client: AgentexSDK) -> None: + def test_raw_response_rpc(self, client: Agentex) -> None: response = client.agents.name.with_raw_response.rpc( agent_name="agent_name", method="event/send", @@ -142,7 +142,7 @@ def test_raw_response_rpc(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_rpc(self, client: AgentexSDK) -> None: + def test_streaming_response_rpc(self, client: Agentex) -> None: with client.agents.name.with_streaming_response.rpc( agent_name="agent_name", method="event/send", @@ -158,7 +158,7 @@ def test_streaming_response_rpc(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_rpc(self, client: AgentexSDK) -> None: + def test_path_params_rpc(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): client.agents.name.with_raw_response.rpc( agent_name="", @@ -174,7 +174,7 @@ class TestAsyncName: @pytest.mark.skip() @parametrize - async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: name = await async_client.agents.name.retrieve( "agent_name", ) @@ -182,7 +182,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.agents.name.with_raw_response.retrieve( "agent_name", ) @@ -194,7 +194,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> Non @pytest.mark.skip() @parametrize - async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.agents.name.with_streaming_response.retrieve( "agent_name", ) as response: @@ -208,7 +208,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) @pytest.mark.skip() @parametrize - async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): await async_client.agents.name.with_raw_response.retrieve( "", @@ -216,7 +216,7 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None @pytest.mark.skip() @parametrize - async def test_method_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_delete(self, async_client: AsyncAgentex) -> None: name = await async_client.agents.name.delete( "agent_name", ) @@ -224,7 +224,7 @@ async def test_method_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: response = await async_client.agents.name.with_raw_response.delete( "agent_name", ) @@ -236,7 +236,7 @@ async def test_raw_response_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> None: async with async_client.agents.name.with_streaming_response.delete( "agent_name", ) as response: @@ -250,7 +250,7 @@ async def test_streaming_response_delete(self, async_client: AsyncAgentexSDK) -> @pytest.mark.skip() @parametrize - async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): await async_client.agents.name.with_raw_response.delete( "", @@ -258,7 +258,7 @@ async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_rpc(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_rpc(self, async_client: AsyncAgentex) -> None: name = await async_client.agents.name.rpc( agent_name="agent_name", method="event/send", @@ -268,7 +268,7 @@ async def test_method_rpc(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_rpc_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_rpc_with_all_params(self, async_client: AsyncAgentex) -> None: name = await async_client.agents.name.rpc( agent_name="agent_name", method="event/send", @@ -283,7 +283,7 @@ async def test_method_rpc_with_all_params(self, async_client: AsyncAgentexSDK) - @pytest.mark.skip() @parametrize - async def test_raw_response_rpc(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_rpc(self, async_client: AsyncAgentex) -> None: response = await async_client.agents.name.with_raw_response.rpc( agent_name="agent_name", method="event/send", @@ -297,7 +297,7 @@ async def test_raw_response_rpc(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_rpc(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_rpc(self, async_client: AsyncAgentex) -> None: async with async_client.agents.name.with_streaming_response.rpc( agent_name="agent_name", method="event/send", @@ -313,7 +313,7 @@ async def test_streaming_response_rpc(self, async_client: AsyncAgentexSDK) -> No @pytest.mark.skip() @parametrize - async def test_path_params_rpc(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_rpc(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): await async_client.agents.name.with_raw_response.rpc( agent_name="", diff --git a/tests/api_resources/messages/test_batch.py b/tests/api_resources/messages/test_batch.py index eb4d99cb..9ad5e59c 100644 --- a/tests/api_resources/messages/test_batch.py +++ b/tests/api_resources/messages/test_batch.py @@ -7,7 +7,7 @@ import pytest -from agentex import AgentexSDK, AsyncAgentexSDK +from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type from agentex.types.messages import BatchCreateResponse, BatchUpdateResponse @@ -19,7 +19,7 @@ class TestBatch: @pytest.mark.skip() @parametrize - def test_method_create(self, client: AgentexSDK) -> None: + def test_method_create(self, client: Agentex) -> None: batch = client.messages.batch.create( contents=[ { @@ -33,7 +33,7 @@ def test_method_create(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_create(self, client: AgentexSDK) -> None: + def test_raw_response_create(self, client: Agentex) -> None: response = client.messages.batch.with_raw_response.create( contents=[ { @@ -51,7 +51,7 @@ def test_raw_response_create(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_create(self, client: AgentexSDK) -> None: + def test_streaming_response_create(self, client: Agentex) -> None: with client.messages.batch.with_streaming_response.create( contents=[ { @@ -71,7 +71,7 @@ def test_streaming_response_create(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_update(self, client: AgentexSDK) -> None: + def test_method_update(self, client: Agentex) -> None: batch = client.messages.batch.update( task_id="task_id", updates={ @@ -85,7 +85,7 @@ def test_method_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_update(self, client: AgentexSDK) -> None: + def test_raw_response_update(self, client: Agentex) -> None: response = client.messages.batch.with_raw_response.update( task_id="task_id", updates={ @@ -103,7 +103,7 @@ def test_raw_response_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_update(self, client: AgentexSDK) -> None: + def test_streaming_response_update(self, client: Agentex) -> None: with client.messages.batch.with_streaming_response.update( task_id="task_id", updates={ @@ -129,7 +129,7 @@ class TestAsyncBatch: @pytest.mark.skip() @parametrize - async def test_method_create(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_create(self, async_client: AsyncAgentex) -> None: batch = await async_client.messages.batch.create( contents=[ { @@ -143,7 +143,7 @@ async def test_method_create(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_create(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_create(self, async_client: AsyncAgentex) -> None: response = await async_client.messages.batch.with_raw_response.create( contents=[ { @@ -161,7 +161,7 @@ async def test_raw_response_create(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_create(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_create(self, async_client: AsyncAgentex) -> None: async with async_client.messages.batch.with_streaming_response.create( contents=[ { @@ -181,7 +181,7 @@ async def test_streaming_response_create(self, async_client: AsyncAgentexSDK) -> @pytest.mark.skip() @parametrize - async def test_method_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_update(self, async_client: AsyncAgentex) -> None: batch = await async_client.messages.batch.update( task_id="task_id", updates={ @@ -195,7 +195,7 @@ async def test_method_update(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: response = await async_client.messages.batch.with_raw_response.update( task_id="task_id", updates={ @@ -213,7 +213,7 @@ async def test_raw_response_update(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_update(self, async_client: AsyncAgentex) -> None: async with async_client.messages.batch.with_streaming_response.update( task_id="task_id", updates={ diff --git a/tests/api_resources/tasks/test_name.py b/tests/api_resources/tasks/test_name.py index 084296a6..cb000659 100644 --- a/tests/api_resources/tasks/test_name.py +++ b/tests/api_resources/tasks/test_name.py @@ -7,7 +7,7 @@ import pytest -from agentex import AgentexSDK, AsyncAgentexSDK +from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type from agentex.types import Task @@ -19,7 +19,7 @@ class TestName: @pytest.mark.skip() @parametrize - def test_method_retrieve(self, client: AgentexSDK) -> None: + def test_method_retrieve(self, client: Agentex) -> None: name = client.tasks.name.retrieve( "task_name", ) @@ -27,7 +27,7 @@ def test_method_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.tasks.name.with_raw_response.retrieve( "task_name", ) @@ -39,7 +39,7 @@ def test_raw_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.tasks.name.with_streaming_response.retrieve( "task_name", ) as response: @@ -53,7 +53,7 @@ def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_retrieve(self, client: AgentexSDK) -> None: + def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): client.tasks.name.with_raw_response.retrieve( "", @@ -61,7 +61,7 @@ def test_path_params_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_delete(self, client: AgentexSDK) -> None: + def test_method_delete(self, client: Agentex) -> None: name = client.tasks.name.delete( "task_name", ) @@ -69,7 +69,7 @@ def test_method_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_delete(self, client: AgentexSDK) -> None: + def test_raw_response_delete(self, client: Agentex) -> None: response = client.tasks.name.with_raw_response.delete( "task_name", ) @@ -81,7 +81,7 @@ def test_raw_response_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_delete(self, client: AgentexSDK) -> None: + def test_streaming_response_delete(self, client: Agentex) -> None: with client.tasks.name.with_streaming_response.delete( "task_name", ) as response: @@ -95,7 +95,7 @@ def test_streaming_response_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_delete(self, client: AgentexSDK) -> None: + def test_path_params_delete(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): client.tasks.name.with_raw_response.delete( "", @@ -103,7 +103,7 @@ def test_path_params_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_stream_events(self, client: AgentexSDK) -> None: + def test_method_stream_events(self, client: Agentex) -> None: name_stream = client.tasks.name.stream_events( "task_name", ) @@ -111,7 +111,7 @@ def test_method_stream_events(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_stream_events(self, client: AgentexSDK) -> None: + def test_raw_response_stream_events(self, client: Agentex) -> None: response = client.tasks.name.with_raw_response.stream_events( "task_name", ) @@ -122,7 +122,7 @@ def test_raw_response_stream_events(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_stream_events(self, client: AgentexSDK) -> None: + def test_streaming_response_stream_events(self, client: Agentex) -> None: with client.tasks.name.with_streaming_response.stream_events( "task_name", ) as response: @@ -136,7 +136,7 @@ def test_streaming_response_stream_events(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_stream_events(self, client: AgentexSDK) -> None: + def test_path_params_stream_events(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): client.tasks.name.with_raw_response.stream_events( "", @@ -150,7 +150,7 @@ class TestAsyncName: @pytest.mark.skip() @parametrize - async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: name = await async_client.tasks.name.retrieve( "task_name", ) @@ -158,7 +158,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.name.with_raw_response.retrieve( "task_name", ) @@ -170,7 +170,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> Non @pytest.mark.skip() @parametrize - async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.name.with_streaming_response.retrieve( "task_name", ) as response: @@ -184,7 +184,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) @pytest.mark.skip() @parametrize - async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): await async_client.tasks.name.with_raw_response.retrieve( "", @@ -192,7 +192,7 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None @pytest.mark.skip() @parametrize - async def test_method_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_delete(self, async_client: AsyncAgentex) -> None: name = await async_client.tasks.name.delete( "task_name", ) @@ -200,7 +200,7 @@ async def test_method_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.name.with_raw_response.delete( "task_name", ) @@ -212,7 +212,7 @@ async def test_raw_response_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.name.with_streaming_response.delete( "task_name", ) as response: @@ -226,7 +226,7 @@ async def test_streaming_response_delete(self, async_client: AsyncAgentexSDK) -> @pytest.mark.skip() @parametrize - async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): await async_client.tasks.name.with_raw_response.delete( "", @@ -234,7 +234,7 @@ async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_stream_events(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_stream_events(self, async_client: AsyncAgentex) -> None: name_stream = await async_client.tasks.name.stream_events( "task_name", ) @@ -242,7 +242,7 @@ async def test_method_stream_events(self, async_client: AsyncAgentexSDK) -> None @pytest.mark.skip() @parametrize - async def test_raw_response_stream_events(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_stream_events(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.name.with_raw_response.stream_events( "task_name", ) @@ -253,7 +253,7 @@ async def test_raw_response_stream_events(self, async_client: AsyncAgentexSDK) - @pytest.mark.skip() @parametrize - async def test_streaming_response_stream_events(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_stream_events(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.name.with_streaming_response.stream_events( "task_name", ) as response: @@ -267,7 +267,7 @@ async def test_streaming_response_stream_events(self, async_client: AsyncAgentex @pytest.mark.skip() @parametrize - async def test_path_params_stream_events(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_stream_events(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): await async_client.tasks.name.with_raw_response.stream_events( "", diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index be59c65d..de1055f7 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -7,7 +7,7 @@ import pytest -from agentex import AgentexSDK, AsyncAgentexSDK +from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type from agentex.types import Agent, AgentListResponse @@ -19,7 +19,7 @@ class TestAgents: @pytest.mark.skip() @parametrize - def test_method_retrieve(self, client: AgentexSDK) -> None: + def test_method_retrieve(self, client: Agentex) -> None: agent = client.agents.retrieve( "agent_id", ) @@ -27,7 +27,7 @@ def test_method_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.agents.with_raw_response.retrieve( "agent_id", ) @@ -39,7 +39,7 @@ def test_raw_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.agents.with_streaming_response.retrieve( "agent_id", ) as response: @@ -53,7 +53,7 @@ def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_retrieve(self, client: AgentexSDK) -> None: + def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): client.agents.with_raw_response.retrieve( "", @@ -61,13 +61,13 @@ def test_path_params_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_list(self, client: AgentexSDK) -> None: + def test_method_list(self, client: Agentex) -> None: agent = client.agents.list() assert_matches_type(AgentListResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize - def test_method_list_with_all_params(self, client: AgentexSDK) -> None: + def test_method_list_with_all_params(self, client: Agentex) -> None: agent = client.agents.list( task_id="task_id", ) @@ -75,7 +75,7 @@ def test_method_list_with_all_params(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_list(self, client: AgentexSDK) -> None: + def test_raw_response_list(self, client: Agentex) -> None: response = client.agents.with_raw_response.list() assert response.is_closed is True @@ -85,7 +85,7 @@ def test_raw_response_list(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_list(self, client: AgentexSDK) -> None: + def test_streaming_response_list(self, client: Agentex) -> None: with client.agents.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -97,7 +97,7 @@ def test_streaming_response_list(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_delete(self, client: AgentexSDK) -> None: + def test_method_delete(self, client: Agentex) -> None: agent = client.agents.delete( "agent_id", ) @@ -105,7 +105,7 @@ def test_method_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_delete(self, client: AgentexSDK) -> None: + def test_raw_response_delete(self, client: Agentex) -> None: response = client.agents.with_raw_response.delete( "agent_id", ) @@ -117,7 +117,7 @@ def test_raw_response_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_delete(self, client: AgentexSDK) -> None: + def test_streaming_response_delete(self, client: Agentex) -> None: with client.agents.with_streaming_response.delete( "agent_id", ) as response: @@ -131,7 +131,7 @@ def test_streaming_response_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_delete(self, client: AgentexSDK) -> None: + def test_path_params_delete(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): client.agents.with_raw_response.delete( "", @@ -139,7 +139,7 @@ def test_path_params_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_rpc(self, client: AgentexSDK) -> None: + def test_method_rpc(self, client: Agentex) -> None: agent = client.agents.rpc( agent_id="agent_id", method="event/send", @@ -149,7 +149,7 @@ def test_method_rpc(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_rpc_with_all_params(self, client: AgentexSDK) -> None: + def test_method_rpc_with_all_params(self, client: Agentex) -> None: agent = client.agents.rpc( agent_id="agent_id", method="event/send", @@ -164,7 +164,7 @@ def test_method_rpc_with_all_params(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_rpc(self, client: AgentexSDK) -> None: + def test_raw_response_rpc(self, client: Agentex) -> None: response = client.agents.with_raw_response.rpc( agent_id="agent_id", method="event/send", @@ -178,7 +178,7 @@ def test_raw_response_rpc(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_rpc(self, client: AgentexSDK) -> None: + def test_streaming_response_rpc(self, client: Agentex) -> None: with client.agents.with_streaming_response.rpc( agent_id="agent_id", method="event/send", @@ -194,7 +194,7 @@ def test_streaming_response_rpc(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_rpc(self, client: AgentexSDK) -> None: + def test_path_params_rpc(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): client.agents.with_raw_response.rpc( agent_id="", @@ -210,7 +210,7 @@ class TestAsyncAgents: @pytest.mark.skip() @parametrize - async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.retrieve( "agent_id", ) @@ -218,7 +218,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.agents.with_raw_response.retrieve( "agent_id", ) @@ -230,7 +230,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> Non @pytest.mark.skip() @parametrize - async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.agents.with_streaming_response.retrieve( "agent_id", ) as response: @@ -244,7 +244,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) @pytest.mark.skip() @parametrize - async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): await async_client.agents.with_raw_response.retrieve( "", @@ -252,13 +252,13 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None @pytest.mark.skip() @parametrize - async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_list(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.list() assert_matches_type(AgentListResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize - async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.list( task_id="task_id", ) @@ -266,7 +266,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) @pytest.mark.skip() @parametrize - async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: response = await async_client.agents.with_raw_response.list() assert response.is_closed is True @@ -276,7 +276,7 @@ async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: async with async_client.agents.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -288,7 +288,7 @@ async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> N @pytest.mark.skip() @parametrize - async def test_method_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_delete(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.delete( "agent_id", ) @@ -296,7 +296,7 @@ async def test_method_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: response = await async_client.agents.with_raw_response.delete( "agent_id", ) @@ -308,7 +308,7 @@ async def test_raw_response_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> None: async with async_client.agents.with_streaming_response.delete( "agent_id", ) as response: @@ -322,7 +322,7 @@ async def test_streaming_response_delete(self, async_client: AsyncAgentexSDK) -> @pytest.mark.skip() @parametrize - async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): await async_client.agents.with_raw_response.delete( "", @@ -330,7 +330,7 @@ async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_rpc(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_rpc(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.rpc( agent_id="agent_id", method="event/send", @@ -340,7 +340,7 @@ async def test_method_rpc(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_rpc_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_rpc_with_all_params(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.rpc( agent_id="agent_id", method="event/send", @@ -355,7 +355,7 @@ async def test_method_rpc_with_all_params(self, async_client: AsyncAgentexSDK) - @pytest.mark.skip() @parametrize - async def test_raw_response_rpc(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_rpc(self, async_client: AsyncAgentex) -> None: response = await async_client.agents.with_raw_response.rpc( agent_id="agent_id", method="event/send", @@ -369,7 +369,7 @@ async def test_raw_response_rpc(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_rpc(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_rpc(self, async_client: AsyncAgentex) -> None: async with async_client.agents.with_streaming_response.rpc( agent_id="agent_id", method="event/send", @@ -385,7 +385,7 @@ async def test_streaming_response_rpc(self, async_client: AsyncAgentexSDK) -> No @pytest.mark.skip() @parametrize - async def test_path_params_rpc(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_rpc(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): await async_client.agents.with_raw_response.rpc( agent_id="", diff --git a/tests/api_resources/test_client.py b/tests/api_resources/test_client.py index 7df05a88..82802d71 100644 --- a/tests/api_resources/test_client.py +++ b/tests/api_resources/test_client.py @@ -7,7 +7,7 @@ import pytest -from agentex import AgentexSDK, AsyncAgentexSDK +from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -18,13 +18,13 @@ class TestClient: @pytest.mark.skip() @parametrize - def test_method_get_root(self, client: AgentexSDK) -> None: + def test_method_get_root(self, client: Agentex) -> None: client_ = client.get_root() assert_matches_type(object, client_, path=["response"]) @pytest.mark.skip() @parametrize - def test_raw_response_get_root(self, client: AgentexSDK) -> None: + def test_raw_response_get_root(self, client: Agentex) -> None: response = client.with_raw_response.get_root() assert response.is_closed is True @@ -34,7 +34,7 @@ def test_raw_response_get_root(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_get_root(self, client: AgentexSDK) -> None: + def test_streaming_response_get_root(self, client: Agentex) -> None: with client.with_streaming_response.get_root() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -52,13 +52,13 @@ class TestAsyncClient: @pytest.mark.skip() @parametrize - async def test_method_get_root(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_get_root(self, async_client: AsyncAgentex) -> None: client = await async_client.get_root() assert_matches_type(object, client, path=["response"]) @pytest.mark.skip() @parametrize - async def test_raw_response_get_root(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_get_root(self, async_client: AsyncAgentex) -> None: response = await async_client.with_raw_response.get_root() assert response.is_closed is True @@ -68,7 +68,7 @@ async def test_raw_response_get_root(self, async_client: AsyncAgentexSDK) -> Non @pytest.mark.skip() @parametrize - async def test_streaming_response_get_root(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_get_root(self, async_client: AsyncAgentex) -> None: async with async_client.with_streaming_response.get_root() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" diff --git a/tests/api_resources/test_echo.py b/tests/api_resources/test_echo.py index 61f2c9c4..1a40d73f 100644 --- a/tests/api_resources/test_echo.py +++ b/tests/api_resources/test_echo.py @@ -7,7 +7,7 @@ import pytest -from agentex import AgentexSDK, AsyncAgentexSDK +from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -18,7 +18,7 @@ class TestEcho: @pytest.mark.skip() @parametrize - def test_method_send(self, client: AgentexSDK) -> None: + def test_method_send(self, client: Agentex) -> None: echo = client.echo.send( message="message", ) @@ -26,7 +26,7 @@ def test_method_send(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_send(self, client: AgentexSDK) -> None: + def test_raw_response_send(self, client: Agentex) -> None: response = client.echo.with_raw_response.send( message="message", ) @@ -38,7 +38,7 @@ def test_raw_response_send(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_send(self, client: AgentexSDK) -> None: + def test_streaming_response_send(self, client: Agentex) -> None: with client.echo.with_streaming_response.send( message="message", ) as response: @@ -58,7 +58,7 @@ class TestAsyncEcho: @pytest.mark.skip() @parametrize - async def test_method_send(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_send(self, async_client: AsyncAgentex) -> None: echo = await async_client.echo.send( message="message", ) @@ -66,7 +66,7 @@ async def test_method_send(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_send(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_send(self, async_client: AsyncAgentex) -> None: response = await async_client.echo.with_raw_response.send( message="message", ) @@ -78,7 +78,7 @@ async def test_raw_response_send(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_send(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_send(self, async_client: AsyncAgentex) -> None: async with async_client.echo.with_streaming_response.send( message="message", ) as response: diff --git a/tests/api_resources/test_events.py b/tests/api_resources/test_events.py index 4543cd61..c11c6c94 100644 --- a/tests/api_resources/test_events.py +++ b/tests/api_resources/test_events.py @@ -7,7 +7,7 @@ import pytest -from agentex import AgentexSDK, AsyncAgentexSDK +from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type from agentex.types import Event, EventListResponse @@ -19,7 +19,7 @@ class TestEvents: @pytest.mark.skip() @parametrize - def test_method_retrieve(self, client: AgentexSDK) -> None: + def test_method_retrieve(self, client: Agentex) -> None: event = client.events.retrieve( "event_id", ) @@ -27,7 +27,7 @@ def test_method_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.events.with_raw_response.retrieve( "event_id", ) @@ -39,7 +39,7 @@ def test_raw_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.events.with_streaming_response.retrieve( "event_id", ) as response: @@ -53,7 +53,7 @@ def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_retrieve(self, client: AgentexSDK) -> None: + def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `event_id` but received ''"): client.events.with_raw_response.retrieve( "", @@ -61,7 +61,7 @@ def test_path_params_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_list(self, client: AgentexSDK) -> None: + def test_method_list(self, client: Agentex) -> None: event = client.events.list( agent_id="agent_id", task_id="task_id", @@ -70,7 +70,7 @@ def test_method_list(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_list_with_all_params(self, client: AgentexSDK) -> None: + def test_method_list_with_all_params(self, client: Agentex) -> None: event = client.events.list( agent_id="agent_id", task_id="task_id", @@ -81,7 +81,7 @@ def test_method_list_with_all_params(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_list(self, client: AgentexSDK) -> None: + def test_raw_response_list(self, client: Agentex) -> None: response = client.events.with_raw_response.list( agent_id="agent_id", task_id="task_id", @@ -94,7 +94,7 @@ def test_raw_response_list(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_list(self, client: AgentexSDK) -> None: + def test_streaming_response_list(self, client: Agentex) -> None: with client.events.with_streaming_response.list( agent_id="agent_id", task_id="task_id", @@ -115,7 +115,7 @@ class TestAsyncEvents: @pytest.mark.skip() @parametrize - async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: event = await async_client.events.retrieve( "event_id", ) @@ -123,7 +123,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.events.with_raw_response.retrieve( "event_id", ) @@ -135,7 +135,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> Non @pytest.mark.skip() @parametrize - async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.events.with_streaming_response.retrieve( "event_id", ) as response: @@ -149,7 +149,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) @pytest.mark.skip() @parametrize - async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `event_id` but received ''"): await async_client.events.with_raw_response.retrieve( "", @@ -157,7 +157,7 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None @pytest.mark.skip() @parametrize - async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_list(self, async_client: AsyncAgentex) -> None: event = await async_client.events.list( agent_id="agent_id", task_id="task_id", @@ -166,7 +166,7 @@ async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: event = await async_client.events.list( agent_id="agent_id", task_id="task_id", @@ -177,7 +177,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) @pytest.mark.skip() @parametrize - async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: response = await async_client.events.with_raw_response.list( agent_id="agent_id", task_id="task_id", @@ -190,7 +190,7 @@ async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: async with async_client.events.with_streaming_response.list( agent_id="agent_id", task_id="task_id", diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py index 9eee20e0..eb0af8cd 100644 --- a/tests/api_resources/test_messages.py +++ b/tests/api_resources/test_messages.py @@ -7,7 +7,7 @@ import pytest -from agentex import AgentexSDK, AsyncAgentexSDK +from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type from agentex.types import ( TaskMessage, @@ -22,7 +22,7 @@ class TestMessages: @pytest.mark.skip() @parametrize - def test_method_create(self, client: AgentexSDK) -> None: + def test_method_create(self, client: Agentex) -> None: message = client.messages.create( content={ "author": "user", @@ -35,7 +35,7 @@ def test_method_create(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_create_with_all_params(self, client: AgentexSDK) -> None: + def test_method_create_with_all_params(self, client: Agentex) -> None: message = client.messages.create( content={ "author": "user", @@ -59,7 +59,7 @@ def test_method_create_with_all_params(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_create(self, client: AgentexSDK) -> None: + def test_raw_response_create(self, client: Agentex) -> None: response = client.messages.with_raw_response.create( content={ "author": "user", @@ -76,7 +76,7 @@ def test_raw_response_create(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_create(self, client: AgentexSDK) -> None: + def test_streaming_response_create(self, client: Agentex) -> None: with client.messages.with_streaming_response.create( content={ "author": "user", @@ -95,7 +95,7 @@ def test_streaming_response_create(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_retrieve(self, client: AgentexSDK) -> None: + def test_method_retrieve(self, client: Agentex) -> None: message = client.messages.retrieve( "message_id", ) @@ -103,7 +103,7 @@ def test_method_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.messages.with_raw_response.retrieve( "message_id", ) @@ -115,7 +115,7 @@ def test_raw_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.messages.with_streaming_response.retrieve( "message_id", ) as response: @@ -129,7 +129,7 @@ def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_retrieve(self, client: AgentexSDK) -> None: + def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"): client.messages.with_raw_response.retrieve( "", @@ -137,7 +137,7 @@ def test_path_params_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_update(self, client: AgentexSDK) -> None: + def test_method_update(self, client: Agentex) -> None: message = client.messages.update( message_id="message_id", content={ @@ -151,7 +151,7 @@ def test_method_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_update_with_all_params(self, client: AgentexSDK) -> None: + def test_method_update_with_all_params(self, client: Agentex) -> None: message = client.messages.update( message_id="message_id", content={ @@ -176,7 +176,7 @@ def test_method_update_with_all_params(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_update(self, client: AgentexSDK) -> None: + def test_raw_response_update(self, client: Agentex) -> None: response = client.messages.with_raw_response.update( message_id="message_id", content={ @@ -194,7 +194,7 @@ def test_raw_response_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_update(self, client: AgentexSDK) -> None: + def test_streaming_response_update(self, client: Agentex) -> None: with client.messages.with_streaming_response.update( message_id="message_id", content={ @@ -214,7 +214,7 @@ def test_streaming_response_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_update(self, client: AgentexSDK) -> None: + def test_path_params_update(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"): client.messages.with_raw_response.update( message_id="", @@ -228,7 +228,7 @@ def test_path_params_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_list(self, client: AgentexSDK) -> None: + def test_method_list(self, client: Agentex) -> None: message = client.messages.list( task_id="task_id", ) @@ -236,7 +236,7 @@ def test_method_list(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_list_with_all_params(self, client: AgentexSDK) -> None: + def test_method_list_with_all_params(self, client: Agentex) -> None: message = client.messages.list( task_id="task_id", limit=0, @@ -245,7 +245,7 @@ def test_method_list_with_all_params(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_list(self, client: AgentexSDK) -> None: + def test_raw_response_list(self, client: Agentex) -> None: response = client.messages.with_raw_response.list( task_id="task_id", ) @@ -257,7 +257,7 @@ def test_raw_response_list(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_list(self, client: AgentexSDK) -> None: + def test_streaming_response_list(self, client: Agentex) -> None: with client.messages.with_streaming_response.list( task_id="task_id", ) as response: @@ -277,7 +277,7 @@ class TestAsyncMessages: @pytest.mark.skip() @parametrize - async def test_method_create(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_create(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.create( content={ "author": "user", @@ -290,7 +290,7 @@ async def test_method_create(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_create_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_create_with_all_params(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.create( content={ "author": "user", @@ -314,7 +314,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncAgentexSDK @pytest.mark.skip() @parametrize - async def test_raw_response_create(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_create(self, async_client: AsyncAgentex) -> None: response = await async_client.messages.with_raw_response.create( content={ "author": "user", @@ -331,7 +331,7 @@ async def test_raw_response_create(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_create(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_create(self, async_client: AsyncAgentex) -> None: async with async_client.messages.with_streaming_response.create( content={ "author": "user", @@ -350,7 +350,7 @@ async def test_streaming_response_create(self, async_client: AsyncAgentexSDK) -> @pytest.mark.skip() @parametrize - async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.retrieve( "message_id", ) @@ -358,7 +358,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.messages.with_raw_response.retrieve( "message_id", ) @@ -370,7 +370,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> Non @pytest.mark.skip() @parametrize - async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.messages.with_streaming_response.retrieve( "message_id", ) as response: @@ -384,7 +384,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) @pytest.mark.skip() @parametrize - async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"): await async_client.messages.with_raw_response.retrieve( "", @@ -392,7 +392,7 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None @pytest.mark.skip() @parametrize - async def test_method_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_update(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.update( message_id="message_id", content={ @@ -406,7 +406,7 @@ async def test_method_update(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_update_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_update_with_all_params(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.update( message_id="message_id", content={ @@ -431,7 +431,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncAgentexSDK @pytest.mark.skip() @parametrize - async def test_raw_response_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: response = await async_client.messages.with_raw_response.update( message_id="message_id", content={ @@ -449,7 +449,7 @@ async def test_raw_response_update(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_update(self, async_client: AsyncAgentex) -> None: async with async_client.messages.with_streaming_response.update( message_id="message_id", content={ @@ -469,7 +469,7 @@ async def test_streaming_response_update(self, async_client: AsyncAgentexSDK) -> @pytest.mark.skip() @parametrize - async def test_path_params_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_update(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"): await async_client.messages.with_raw_response.update( message_id="", @@ -483,7 +483,7 @@ async def test_path_params_update(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_list(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.list( task_id="task_id", ) @@ -491,7 +491,7 @@ async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.list( task_id="task_id", limit=0, @@ -500,7 +500,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) @pytest.mark.skip() @parametrize - async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: response = await async_client.messages.with_raw_response.list( task_id="task_id", ) @@ -512,7 +512,7 @@ async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: async with async_client.messages.with_streaming_response.list( task_id="task_id", ) as response: diff --git a/tests/api_resources/test_spans.py b/tests/api_resources/test_spans.py index 7032fec9..344b7779 100644 --- a/tests/api_resources/test_spans.py +++ b/tests/api_resources/test_spans.py @@ -7,7 +7,7 @@ import pytest -from agentex import AgentexSDK, AsyncAgentexSDK +from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type from agentex.types import Span, SpanListResponse from agentex._utils import parse_datetime @@ -20,7 +20,7 @@ class TestSpans: @pytest.mark.skip() @parametrize - def test_method_create(self, client: AgentexSDK) -> None: + def test_method_create(self, client: Agentex) -> None: span = client.spans.create( name="name", start_time=parse_datetime("2019-12-27T18:11:19.117Z"), @@ -30,7 +30,7 @@ def test_method_create(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_create_with_all_params(self, client: AgentexSDK) -> None: + def test_method_create_with_all_params(self, client: Agentex) -> None: span = client.spans.create( name="name", start_time=parse_datetime("2019-12-27T18:11:19.117Z"), @@ -46,7 +46,7 @@ def test_method_create_with_all_params(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_create(self, client: AgentexSDK) -> None: + def test_raw_response_create(self, client: Agentex) -> None: response = client.spans.with_raw_response.create( name="name", start_time=parse_datetime("2019-12-27T18:11:19.117Z"), @@ -60,7 +60,7 @@ def test_raw_response_create(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_create(self, client: AgentexSDK) -> None: + def test_streaming_response_create(self, client: Agentex) -> None: with client.spans.with_streaming_response.create( name="name", start_time=parse_datetime("2019-12-27T18:11:19.117Z"), @@ -76,7 +76,7 @@ def test_streaming_response_create(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_retrieve(self, client: AgentexSDK) -> None: + def test_method_retrieve(self, client: Agentex) -> None: span = client.spans.retrieve( "span_id", ) @@ -84,7 +84,7 @@ def test_method_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.spans.with_raw_response.retrieve( "span_id", ) @@ -96,7 +96,7 @@ def test_raw_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.spans.with_streaming_response.retrieve( "span_id", ) as response: @@ -110,7 +110,7 @@ def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_retrieve(self, client: AgentexSDK) -> None: + def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `span_id` but received ''"): client.spans.with_raw_response.retrieve( "", @@ -118,7 +118,7 @@ def test_path_params_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_update(self, client: AgentexSDK) -> None: + def test_method_update(self, client: Agentex) -> None: span = client.spans.update( span_id="span_id", ) @@ -126,7 +126,7 @@ def test_method_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_update_with_all_params(self, client: AgentexSDK) -> None: + def test_method_update_with_all_params(self, client: Agentex) -> None: span = client.spans.update( span_id="span_id", data={"foo": "bar"}, @@ -142,7 +142,7 @@ def test_method_update_with_all_params(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_update(self, client: AgentexSDK) -> None: + def test_raw_response_update(self, client: Agentex) -> None: response = client.spans.with_raw_response.update( span_id="span_id", ) @@ -154,7 +154,7 @@ def test_raw_response_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_update(self, client: AgentexSDK) -> None: + def test_streaming_response_update(self, client: Agentex) -> None: with client.spans.with_streaming_response.update( span_id="span_id", ) as response: @@ -168,7 +168,7 @@ def test_streaming_response_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_update(self, client: AgentexSDK) -> None: + def test_path_params_update(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `span_id` but received ''"): client.spans.with_raw_response.update( span_id="", @@ -176,13 +176,13 @@ def test_path_params_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_list(self, client: AgentexSDK) -> None: + def test_method_list(self, client: Agentex) -> None: span = client.spans.list() assert_matches_type(SpanListResponse, span, path=["response"]) @pytest.mark.skip() @parametrize - def test_method_list_with_all_params(self, client: AgentexSDK) -> None: + def test_method_list_with_all_params(self, client: Agentex) -> None: span = client.spans.list( trace_id="trace_id", ) @@ -190,7 +190,7 @@ def test_method_list_with_all_params(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_list(self, client: AgentexSDK) -> None: + def test_raw_response_list(self, client: Agentex) -> None: response = client.spans.with_raw_response.list() assert response.is_closed is True @@ -200,7 +200,7 @@ def test_raw_response_list(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_list(self, client: AgentexSDK) -> None: + def test_streaming_response_list(self, client: Agentex) -> None: with client.spans.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -218,7 +218,7 @@ class TestAsyncSpans: @pytest.mark.skip() @parametrize - async def test_method_create(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_create(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.create( name="name", start_time=parse_datetime("2019-12-27T18:11:19.117Z"), @@ -228,7 +228,7 @@ async def test_method_create(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_create_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_create_with_all_params(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.create( name="name", start_time=parse_datetime("2019-12-27T18:11:19.117Z"), @@ -244,7 +244,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncAgentexSDK @pytest.mark.skip() @parametrize - async def test_raw_response_create(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_create(self, async_client: AsyncAgentex) -> None: response = await async_client.spans.with_raw_response.create( name="name", start_time=parse_datetime("2019-12-27T18:11:19.117Z"), @@ -258,7 +258,7 @@ async def test_raw_response_create(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_create(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_create(self, async_client: AsyncAgentex) -> None: async with async_client.spans.with_streaming_response.create( name="name", start_time=parse_datetime("2019-12-27T18:11:19.117Z"), @@ -274,7 +274,7 @@ async def test_streaming_response_create(self, async_client: AsyncAgentexSDK) -> @pytest.mark.skip() @parametrize - async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.retrieve( "span_id", ) @@ -282,7 +282,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.spans.with_raw_response.retrieve( "span_id", ) @@ -294,7 +294,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> Non @pytest.mark.skip() @parametrize - async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.spans.with_streaming_response.retrieve( "span_id", ) as response: @@ -308,7 +308,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) @pytest.mark.skip() @parametrize - async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `span_id` but received ''"): await async_client.spans.with_raw_response.retrieve( "", @@ -316,7 +316,7 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None @pytest.mark.skip() @parametrize - async def test_method_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_update(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.update( span_id="span_id", ) @@ -324,7 +324,7 @@ async def test_method_update(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_update_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_update_with_all_params(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.update( span_id="span_id", data={"foo": "bar"}, @@ -340,7 +340,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncAgentexSDK @pytest.mark.skip() @parametrize - async def test_raw_response_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: response = await async_client.spans.with_raw_response.update( span_id="span_id", ) @@ -352,7 +352,7 @@ async def test_raw_response_update(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_update(self, async_client: AsyncAgentex) -> None: async with async_client.spans.with_streaming_response.update( span_id="span_id", ) as response: @@ -366,7 +366,7 @@ async def test_streaming_response_update(self, async_client: AsyncAgentexSDK) -> @pytest.mark.skip() @parametrize - async def test_path_params_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_update(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `span_id` but received ''"): await async_client.spans.with_raw_response.update( span_id="", @@ -374,13 +374,13 @@ async def test_path_params_update(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_list(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.list() assert_matches_type(SpanListResponse, span, path=["response"]) @pytest.mark.skip() @parametrize - async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.list( trace_id="trace_id", ) @@ -388,7 +388,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) @pytest.mark.skip() @parametrize - async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: response = await async_client.spans.with_raw_response.list() assert response.is_closed is True @@ -398,7 +398,7 @@ async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: async with async_client.spans.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" diff --git a/tests/api_resources/test_states.py b/tests/api_resources/test_states.py index 22bd9f01..8e4fc62c 100644 --- a/tests/api_resources/test_states.py +++ b/tests/api_resources/test_states.py @@ -7,7 +7,7 @@ import pytest -from agentex import AgentexSDK, AsyncAgentexSDK +from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type from agentex.types import State, StateListResponse @@ -19,7 +19,7 @@ class TestStates: @pytest.mark.skip() @parametrize - def test_method_create(self, client: AgentexSDK) -> None: + def test_method_create(self, client: Agentex) -> None: state = client.states.create( agent_id="agent_id", state={"foo": "bar"}, @@ -29,7 +29,7 @@ def test_method_create(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_create(self, client: AgentexSDK) -> None: + def test_raw_response_create(self, client: Agentex) -> None: response = client.states.with_raw_response.create( agent_id="agent_id", state={"foo": "bar"}, @@ -43,7 +43,7 @@ def test_raw_response_create(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_create(self, client: AgentexSDK) -> None: + def test_streaming_response_create(self, client: Agentex) -> None: with client.states.with_streaming_response.create( agent_id="agent_id", state={"foo": "bar"}, @@ -59,7 +59,7 @@ def test_streaming_response_create(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_retrieve(self, client: AgentexSDK) -> None: + def test_method_retrieve(self, client: Agentex) -> None: state = client.states.retrieve( "state_id", ) @@ -67,7 +67,7 @@ def test_method_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.states.with_raw_response.retrieve( "state_id", ) @@ -79,7 +79,7 @@ def test_raw_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.states.with_streaming_response.retrieve( "state_id", ) as response: @@ -93,7 +93,7 @@ def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_retrieve(self, client: AgentexSDK) -> None: + def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): client.states.with_raw_response.retrieve( "", @@ -101,7 +101,7 @@ def test_path_params_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_update(self, client: AgentexSDK) -> None: + def test_method_update(self, client: Agentex) -> None: state = client.states.update( state_id="state_id", agent_id="agent_id", @@ -112,7 +112,7 @@ def test_method_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_update(self, client: AgentexSDK) -> None: + def test_raw_response_update(self, client: Agentex) -> None: response = client.states.with_raw_response.update( state_id="state_id", agent_id="agent_id", @@ -127,7 +127,7 @@ def test_raw_response_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_update(self, client: AgentexSDK) -> None: + def test_streaming_response_update(self, client: Agentex) -> None: with client.states.with_streaming_response.update( state_id="state_id", agent_id="agent_id", @@ -144,7 +144,7 @@ def test_streaming_response_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_update(self, client: AgentexSDK) -> None: + def test_path_params_update(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): client.states.with_raw_response.update( state_id="", @@ -155,13 +155,13 @@ def test_path_params_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_list(self, client: AgentexSDK) -> None: + def test_method_list(self, client: Agentex) -> None: state = client.states.list() assert_matches_type(StateListResponse, state, path=["response"]) @pytest.mark.skip() @parametrize - def test_method_list_with_all_params(self, client: AgentexSDK) -> None: + def test_method_list_with_all_params(self, client: Agentex) -> None: state = client.states.list( agent_id="agent_id", task_id="task_id", @@ -170,7 +170,7 @@ def test_method_list_with_all_params(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_list(self, client: AgentexSDK) -> None: + def test_raw_response_list(self, client: Agentex) -> None: response = client.states.with_raw_response.list() assert response.is_closed is True @@ -180,7 +180,7 @@ def test_raw_response_list(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_list(self, client: AgentexSDK) -> None: + def test_streaming_response_list(self, client: Agentex) -> None: with client.states.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -192,7 +192,7 @@ def test_streaming_response_list(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_delete(self, client: AgentexSDK) -> None: + def test_method_delete(self, client: Agentex) -> None: state = client.states.delete( "state_id", ) @@ -200,7 +200,7 @@ def test_method_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_delete(self, client: AgentexSDK) -> None: + def test_raw_response_delete(self, client: Agentex) -> None: response = client.states.with_raw_response.delete( "state_id", ) @@ -212,7 +212,7 @@ def test_raw_response_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_delete(self, client: AgentexSDK) -> None: + def test_streaming_response_delete(self, client: Agentex) -> None: with client.states.with_streaming_response.delete( "state_id", ) as response: @@ -226,7 +226,7 @@ def test_streaming_response_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_delete(self, client: AgentexSDK) -> None: + def test_path_params_delete(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): client.states.with_raw_response.delete( "", @@ -240,7 +240,7 @@ class TestAsyncStates: @pytest.mark.skip() @parametrize - async def test_method_create(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_create(self, async_client: AsyncAgentex) -> None: state = await async_client.states.create( agent_id="agent_id", state={"foo": "bar"}, @@ -250,7 +250,7 @@ async def test_method_create(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_create(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_create(self, async_client: AsyncAgentex) -> None: response = await async_client.states.with_raw_response.create( agent_id="agent_id", state={"foo": "bar"}, @@ -264,7 +264,7 @@ async def test_raw_response_create(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_create(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_create(self, async_client: AsyncAgentex) -> None: async with async_client.states.with_streaming_response.create( agent_id="agent_id", state={"foo": "bar"}, @@ -280,7 +280,7 @@ async def test_streaming_response_create(self, async_client: AsyncAgentexSDK) -> @pytest.mark.skip() @parametrize - async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: state = await async_client.states.retrieve( "state_id", ) @@ -288,7 +288,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.states.with_raw_response.retrieve( "state_id", ) @@ -300,7 +300,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> Non @pytest.mark.skip() @parametrize - async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.states.with_streaming_response.retrieve( "state_id", ) as response: @@ -314,7 +314,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) @pytest.mark.skip() @parametrize - async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): await async_client.states.with_raw_response.retrieve( "", @@ -322,7 +322,7 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None @pytest.mark.skip() @parametrize - async def test_method_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_update(self, async_client: AsyncAgentex) -> None: state = await async_client.states.update( state_id="state_id", agent_id="agent_id", @@ -333,7 +333,7 @@ async def test_method_update(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: response = await async_client.states.with_raw_response.update( state_id="state_id", agent_id="agent_id", @@ -348,7 +348,7 @@ async def test_raw_response_update(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_update(self, async_client: AsyncAgentex) -> None: async with async_client.states.with_streaming_response.update( state_id="state_id", agent_id="agent_id", @@ -365,7 +365,7 @@ async def test_streaming_response_update(self, async_client: AsyncAgentexSDK) -> @pytest.mark.skip() @parametrize - async def test_path_params_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_update(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): await async_client.states.with_raw_response.update( state_id="", @@ -376,13 +376,13 @@ async def test_path_params_update(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_list(self, async_client: AsyncAgentex) -> None: state = await async_client.states.list() assert_matches_type(StateListResponse, state, path=["response"]) @pytest.mark.skip() @parametrize - async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: state = await async_client.states.list( agent_id="agent_id", task_id="task_id", @@ -391,7 +391,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) @pytest.mark.skip() @parametrize - async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: response = await async_client.states.with_raw_response.list() assert response.is_closed is True @@ -401,7 +401,7 @@ async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: async with async_client.states.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -413,7 +413,7 @@ async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> N @pytest.mark.skip() @parametrize - async def test_method_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_delete(self, async_client: AsyncAgentex) -> None: state = await async_client.states.delete( "state_id", ) @@ -421,7 +421,7 @@ async def test_method_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: response = await async_client.states.with_raw_response.delete( "state_id", ) @@ -433,7 +433,7 @@ async def test_raw_response_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> None: async with async_client.states.with_streaming_response.delete( "state_id", ) as response: @@ -447,7 +447,7 @@ async def test_streaming_response_delete(self, async_client: AsyncAgentexSDK) -> @pytest.mark.skip() @parametrize - async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): await async_client.states.with_raw_response.delete( "", diff --git a/tests/api_resources/test_tasks.py b/tests/api_resources/test_tasks.py index 048f8a03..060f051c 100644 --- a/tests/api_resources/test_tasks.py +++ b/tests/api_resources/test_tasks.py @@ -7,7 +7,7 @@ import pytest -from agentex import AgentexSDK, AsyncAgentexSDK +from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type from agentex.types import Task, TaskListResponse @@ -19,7 +19,7 @@ class TestTasks: @pytest.mark.skip() @parametrize - def test_method_retrieve(self, client: AgentexSDK) -> None: + def test_method_retrieve(self, client: Agentex) -> None: task = client.tasks.retrieve( "task_id", ) @@ -27,7 +27,7 @@ def test_method_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.tasks.with_raw_response.retrieve( "task_id", ) @@ -39,7 +39,7 @@ def test_raw_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.tasks.with_streaming_response.retrieve( "task_id", ) as response: @@ -53,7 +53,7 @@ def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_retrieve(self, client: AgentexSDK) -> None: + def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): client.tasks.with_raw_response.retrieve( "", @@ -61,13 +61,13 @@ def test_path_params_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_list(self, client: AgentexSDK) -> None: + def test_method_list(self, client: Agentex) -> None: task = client.tasks.list() assert_matches_type(TaskListResponse, task, path=["response"]) @pytest.mark.skip() @parametrize - def test_raw_response_list(self, client: AgentexSDK) -> None: + def test_raw_response_list(self, client: Agentex) -> None: response = client.tasks.with_raw_response.list() assert response.is_closed is True @@ -77,7 +77,7 @@ def test_raw_response_list(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_list(self, client: AgentexSDK) -> None: + def test_streaming_response_list(self, client: Agentex) -> None: with client.tasks.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -89,7 +89,7 @@ def test_streaming_response_list(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_delete(self, client: AgentexSDK) -> None: + def test_method_delete(self, client: Agentex) -> None: task = client.tasks.delete( "task_id", ) @@ -97,7 +97,7 @@ def test_method_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_delete(self, client: AgentexSDK) -> None: + def test_raw_response_delete(self, client: Agentex) -> None: response = client.tasks.with_raw_response.delete( "task_id", ) @@ -109,7 +109,7 @@ def test_raw_response_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_delete(self, client: AgentexSDK) -> None: + def test_streaming_response_delete(self, client: Agentex) -> None: with client.tasks.with_streaming_response.delete( "task_id", ) as response: @@ -123,7 +123,7 @@ def test_streaming_response_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_delete(self, client: AgentexSDK) -> None: + def test_path_params_delete(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): client.tasks.with_raw_response.delete( "", @@ -131,7 +131,7 @@ def test_path_params_delete(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_stream_events(self, client: AgentexSDK) -> None: + def test_method_stream_events(self, client: Agentex) -> None: task_stream = client.tasks.stream_events( "task_id", ) @@ -139,7 +139,7 @@ def test_method_stream_events(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_stream_events(self, client: AgentexSDK) -> None: + def test_raw_response_stream_events(self, client: Agentex) -> None: response = client.tasks.with_raw_response.stream_events( "task_id", ) @@ -150,7 +150,7 @@ def test_raw_response_stream_events(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_stream_events(self, client: AgentexSDK) -> None: + def test_streaming_response_stream_events(self, client: Agentex) -> None: with client.tasks.with_streaming_response.stream_events( "task_id", ) as response: @@ -164,7 +164,7 @@ def test_streaming_response_stream_events(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_stream_events(self, client: AgentexSDK) -> None: + def test_path_params_stream_events(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): client.tasks.with_raw_response.stream_events( "", @@ -178,7 +178,7 @@ class TestAsyncTasks: @pytest.mark.skip() @parametrize - async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.retrieve( "task_id", ) @@ -186,7 +186,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.retrieve( "task_id", ) @@ -198,7 +198,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> Non @pytest.mark.skip() @parametrize - async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.retrieve( "task_id", ) as response: @@ -212,7 +212,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) @pytest.mark.skip() @parametrize - async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): await async_client.tasks.with_raw_response.retrieve( "", @@ -220,13 +220,13 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None @pytest.mark.skip() @parametrize - async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_list(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.list() assert_matches_type(TaskListResponse, task, path=["response"]) @pytest.mark.skip() @parametrize - async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.list() assert response.is_closed is True @@ -236,7 +236,7 @@ async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -248,7 +248,7 @@ async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> N @pytest.mark.skip() @parametrize - async def test_method_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_delete(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.delete( "task_id", ) @@ -256,7 +256,7 @@ async def test_method_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.delete( "task_id", ) @@ -268,7 +268,7 @@ async def test_raw_response_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.delete( "task_id", ) as response: @@ -282,7 +282,7 @@ async def test_streaming_response_delete(self, async_client: AsyncAgentexSDK) -> @pytest.mark.skip() @parametrize - async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): await async_client.tasks.with_raw_response.delete( "", @@ -290,7 +290,7 @@ async def test_path_params_delete(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_stream_events(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_stream_events(self, async_client: AsyncAgentex) -> None: task_stream = await async_client.tasks.stream_events( "task_id", ) @@ -298,7 +298,7 @@ async def test_method_stream_events(self, async_client: AsyncAgentexSDK) -> None @pytest.mark.skip() @parametrize - async def test_raw_response_stream_events(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_stream_events(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.stream_events( "task_id", ) @@ -309,7 +309,7 @@ async def test_raw_response_stream_events(self, async_client: AsyncAgentexSDK) - @pytest.mark.skip() @parametrize - async def test_streaming_response_stream_events(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_stream_events(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.stream_events( "task_id", ) as response: @@ -323,7 +323,7 @@ async def test_streaming_response_stream_events(self, async_client: AsyncAgentex @pytest.mark.skip() @parametrize - async def test_path_params_stream_events(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_stream_events(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): await async_client.tasks.with_raw_response.stream_events( "", diff --git a/tests/api_resources/test_tracker.py b/tests/api_resources/test_tracker.py index c93c4e88..11366810 100644 --- a/tests/api_resources/test_tracker.py +++ b/tests/api_resources/test_tracker.py @@ -7,7 +7,7 @@ import pytest -from agentex import AgentexSDK, AsyncAgentexSDK +from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type from agentex.types import AgentTaskTracker, TrackerListResponse @@ -19,7 +19,7 @@ class TestTracker: @pytest.mark.skip() @parametrize - def test_method_retrieve(self, client: AgentexSDK) -> None: + def test_method_retrieve(self, client: Agentex) -> None: tracker = client.tracker.retrieve( "tracker_id", ) @@ -27,7 +27,7 @@ def test_method_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_retrieve(self, client: AgentexSDK) -> None: + def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.tracker.with_raw_response.retrieve( "tracker_id", ) @@ -39,7 +39,7 @@ def test_raw_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: + def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.tracker.with_streaming_response.retrieve( "tracker_id", ) as response: @@ -53,7 +53,7 @@ def test_streaming_response_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_retrieve(self, client: AgentexSDK) -> None: + def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `tracker_id` but received ''"): client.tracker.with_raw_response.retrieve( "", @@ -61,7 +61,7 @@ def test_path_params_retrieve(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_update(self, client: AgentexSDK) -> None: + def test_method_update(self, client: Agentex) -> None: tracker = client.tracker.update( tracker_id="tracker_id", ) @@ -69,7 +69,7 @@ def test_method_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_update_with_all_params(self, client: AgentexSDK) -> None: + def test_method_update_with_all_params(self, client: Agentex) -> None: tracker = client.tracker.update( tracker_id="tracker_id", last_processed_event_id="last_processed_event_id", @@ -80,7 +80,7 @@ def test_method_update_with_all_params(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_update(self, client: AgentexSDK) -> None: + def test_raw_response_update(self, client: Agentex) -> None: response = client.tracker.with_raw_response.update( tracker_id="tracker_id", ) @@ -92,7 +92,7 @@ def test_raw_response_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_update(self, client: AgentexSDK) -> None: + def test_streaming_response_update(self, client: Agentex) -> None: with client.tracker.with_streaming_response.update( tracker_id="tracker_id", ) as response: @@ -106,7 +106,7 @@ def test_streaming_response_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_path_params_update(self, client: AgentexSDK) -> None: + def test_path_params_update(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `tracker_id` but received ''"): client.tracker.with_raw_response.update( tracker_id="", @@ -114,13 +114,13 @@ def test_path_params_update(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_method_list(self, client: AgentexSDK) -> None: + def test_method_list(self, client: Agentex) -> None: tracker = client.tracker.list() assert_matches_type(TrackerListResponse, tracker, path=["response"]) @pytest.mark.skip() @parametrize - def test_method_list_with_all_params(self, client: AgentexSDK) -> None: + def test_method_list_with_all_params(self, client: Agentex) -> None: tracker = client.tracker.list( agent_id="agent_id", task_id="task_id", @@ -129,7 +129,7 @@ def test_method_list_with_all_params(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_raw_response_list(self, client: AgentexSDK) -> None: + def test_raw_response_list(self, client: Agentex) -> None: response = client.tracker.with_raw_response.list() assert response.is_closed is True @@ -139,7 +139,7 @@ def test_raw_response_list(self, client: AgentexSDK) -> None: @pytest.mark.skip() @parametrize - def test_streaming_response_list(self, client: AgentexSDK) -> None: + def test_streaming_response_list(self, client: Agentex) -> None: with client.tracker.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -157,7 +157,7 @@ class TestAsyncTracker: @pytest.mark.skip() @parametrize - async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: tracker = await async_client.tracker.retrieve( "tracker_id", ) @@ -165,7 +165,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.tracker.with_raw_response.retrieve( "tracker_id", ) @@ -177,7 +177,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentexSDK) -> Non @pytest.mark.skip() @parametrize - async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.tracker.with_streaming_response.retrieve( "tracker_id", ) as response: @@ -191,7 +191,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentexSDK) @pytest.mark.skip() @parametrize - async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `tracker_id` but received ''"): await async_client.tracker.with_raw_response.retrieve( "", @@ -199,7 +199,7 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentexSDK) -> None @pytest.mark.skip() @parametrize - async def test_method_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_update(self, async_client: AsyncAgentex) -> None: tracker = await async_client.tracker.update( tracker_id="tracker_id", ) @@ -207,7 +207,7 @@ async def test_method_update(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_update_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_update_with_all_params(self, async_client: AsyncAgentex) -> None: tracker = await async_client.tracker.update( tracker_id="tracker_id", last_processed_event_id="last_processed_event_id", @@ -218,7 +218,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncAgentexSDK @pytest.mark.skip() @parametrize - async def test_raw_response_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: response = await async_client.tracker.with_raw_response.update( tracker_id="tracker_id", ) @@ -230,7 +230,7 @@ async def test_raw_response_update(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_update(self, async_client: AsyncAgentex) -> None: async with async_client.tracker.with_streaming_response.update( tracker_id="tracker_id", ) as response: @@ -244,7 +244,7 @@ async def test_streaming_response_update(self, async_client: AsyncAgentexSDK) -> @pytest.mark.skip() @parametrize - async def test_path_params_update(self, async_client: AsyncAgentexSDK) -> None: + async def test_path_params_update(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `tracker_id` but received ''"): await async_client.tracker.with_raw_response.update( tracker_id="", @@ -252,13 +252,13 @@ async def test_path_params_update(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_method_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_list(self, async_client: AsyncAgentex) -> None: tracker = await async_client.tracker.list() assert_matches_type(TrackerListResponse, tracker, path=["response"]) @pytest.mark.skip() @parametrize - async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) -> None: + async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: tracker = await async_client.tracker.list( agent_id="agent_id", task_id="task_id", @@ -267,7 +267,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentexSDK) @pytest.mark.skip() @parametrize - async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: response = await async_client.tracker.with_raw_response.list() assert response.is_closed is True @@ -277,7 +277,7 @@ async def test_raw_response_list(self, async_client: AsyncAgentexSDK) -> None: @pytest.mark.skip() @parametrize - async def test_streaming_response_list(self, async_client: AsyncAgentexSDK) -> None: + async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: async with async_client.tracker.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" diff --git a/tests/conftest.py b/tests/conftest.py index 5fddcb23..d08e65cf 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -10,7 +10,7 @@ import pytest from pytest_asyncio import is_async_test -from agentex import AgentexSDK, AsyncAgentexSDK, DefaultAioHttpClient +from agentex import Agentex, AsyncAgentex, DefaultAioHttpClient from agentex._utils import is_dict if TYPE_CHECKING: @@ -49,17 +49,17 @@ def pytest_collection_modifyitems(items: list[pytest.Function]) -> None: @pytest.fixture(scope="session") -def client(request: FixtureRequest) -> Iterator[AgentexSDK]: +def client(request: FixtureRequest) -> Iterator[Agentex]: strict = getattr(request, "param", True) if not isinstance(strict, bool): raise TypeError(f"Unexpected fixture parameter type {type(strict)}, expected {bool}") - with AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=strict) as client: + with Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=strict) as client: yield client @pytest.fixture(scope="session") -async def async_client(request: FixtureRequest) -> AsyncIterator[AsyncAgentexSDK]: +async def async_client(request: FixtureRequest) -> AsyncIterator[AsyncAgentex]: param = getattr(request, "param", True) # defaults @@ -78,7 +78,7 @@ async def async_client(request: FixtureRequest) -> AsyncIterator[AsyncAgentexSDK else: raise TypeError(f"Unexpected fixture parameter type {type(param)}, expected bool or dict") - async with AsyncAgentexSDK( + async with AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=strict, http_client=http_client ) as client: yield client diff --git a/tests/test_client.py b/tests/test_client.py index d6a03e84..bb8ce7ed 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -21,7 +21,7 @@ from respx import MockRouter from pydantic import ValidationError -from agentex import AgentexSDK, AsyncAgentexSDK, APIResponseValidationError +from agentex import Agentex, AsyncAgentex, APIResponseValidationError from agentex._types import Omit from agentex._models import BaseModel, FinalRequestOptions from agentex._exceptions import APIStatusError, APITimeoutError, APIResponseValidationError @@ -50,7 +50,7 @@ def _low_retry_timeout(*_args: Any, **_kwargs: Any) -> float: return 0.1 -def _get_open_connections(client: AgentexSDK | AsyncAgentexSDK) -> int: +def _get_open_connections(client: Agentex | AsyncAgentex) -> int: transport = client._client._transport assert isinstance(transport, httpx.HTTPTransport) or isinstance(transport, httpx.AsyncHTTPTransport) @@ -58,8 +58,8 @@ def _get_open_connections(client: AgentexSDK | AsyncAgentexSDK) -> int: return len(pool._requests) -class TestAgentexSDK: - client = AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) +class TestAgentex: + client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) @pytest.mark.respx(base_url=base_url) def test_raw_response(self, respx_mock: MockRouter) -> None: @@ -106,7 +106,7 @@ def test_copy_default_options(self) -> None: assert isinstance(self.client.timeout, httpx.Timeout) def test_copy_default_headers(self) -> None: - client = AgentexSDK( + client = Agentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} ) assert client.default_headers["X-Foo"] == "bar" @@ -140,7 +140,7 @@ def test_copy_default_headers(self) -> None: client.copy(set_default_headers={}, default_headers={"X-Foo": "Bar"}) def test_copy_default_query(self) -> None: - client = AgentexSDK( + client = Agentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"foo": "bar"} ) assert _get_params(client)["foo"] == "bar" @@ -266,9 +266,7 @@ def test_request_timeout(self) -> None: assert timeout == httpx.Timeout(100.0) def test_client_timeout_option(self) -> None: - client = AgentexSDK( - base_url=base_url, api_key=api_key, _strict_response_validation=True, timeout=httpx.Timeout(0) - ) + client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True, timeout=httpx.Timeout(0)) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -277,7 +275,7 @@ def test_client_timeout_option(self) -> None: def test_http_client_timeout_option(self) -> None: # custom timeout given to the httpx client should be used with httpx.Client(timeout=None) as http_client: - client = AgentexSDK( + client = Agentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client ) @@ -287,7 +285,7 @@ def test_http_client_timeout_option(self) -> None: # no timeout given to the httpx client should not use the httpx default with httpx.Client() as http_client: - client = AgentexSDK( + client = Agentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client ) @@ -297,7 +295,7 @@ def test_http_client_timeout_option(self) -> None: # explicitly passing the default timeout currently results in it being ignored with httpx.Client(timeout=HTTPX_DEFAULT_TIMEOUT) as http_client: - client = AgentexSDK( + client = Agentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client ) @@ -308,7 +306,7 @@ def test_http_client_timeout_option(self) -> None: async def test_invalid_http_client(self) -> None: with pytest.raises(TypeError, match="Invalid `http_client` arg"): async with httpx.AsyncClient() as http_client: - AgentexSDK( + Agentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, @@ -316,14 +314,14 @@ async def test_invalid_http_client(self) -> None: ) def test_default_headers_option(self) -> None: - client = AgentexSDK( + client = Agentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} ) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) assert request.headers.get("x-foo") == "bar" assert request.headers.get("x-stainless-lang") == "python" - client2 = AgentexSDK( + client2 = Agentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, @@ -337,12 +335,12 @@ def test_default_headers_option(self) -> None: assert request.headers.get("x-stainless-lang") == "my-overriding-header" def test_validate_headers(self) -> None: - client = AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) assert request.headers.get("Authorization") == f"Bearer {api_key}" with update_env(**{"AGENTEX_SDK_API_KEY": Omit()}): - client2 = AgentexSDK(base_url=base_url, api_key=None, _strict_response_validation=True) + client2 = Agentex(base_url=base_url, api_key=None, _strict_response_validation=True) with pytest.raises( TypeError, @@ -356,7 +354,7 @@ def test_validate_headers(self) -> None: assert request2.headers.get("Authorization") is None def test_default_query_option(self) -> None: - client = AgentexSDK( + client = Agentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"query_param": "bar"} ) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) @@ -470,7 +468,7 @@ def test_request_extra_query(self) -> None: params = dict(request.url.params) assert params == {"foo": "2"} - def test_multipart_repeating_array(self, client: AgentexSDK) -> None: + def test_multipart_repeating_array(self, client: Agentex) -> None: request = client._build_request( FinalRequestOptions.construct( method="post", @@ -557,7 +555,7 @@ class Model(BaseModel): assert response.foo == 2 def test_base_url_setter(self) -> None: - client = AgentexSDK(base_url="https://example.com/from_init", api_key=api_key, _strict_response_validation=True) + client = Agentex(base_url="https://example.com/from_init", api_key=api_key, _strict_response_validation=True) assert client.base_url == "https://example.com/from_init/" client.base_url = "https://example.com/from_setter" # type: ignore[assignment] @@ -565,17 +563,15 @@ def test_base_url_setter(self) -> None: assert client.base_url == "https://example.com/from_setter/" def test_base_url_env(self) -> None: - with update_env(AGENTEX_SDK_BASE_URL="http://localhost:5000/from/env"): - client = AgentexSDK(api_key=api_key, _strict_response_validation=True) + with update_env(AGENTEX_BASE_URL="http://localhost:5000/from/env"): + client = Agentex(api_key=api_key, _strict_response_validation=True) assert client.base_url == "http://localhost:5000/from/env/" @pytest.mark.parametrize( "client", [ - AgentexSDK( - base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True - ), - AgentexSDK( + Agentex(base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True), + Agentex( base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True, @@ -584,7 +580,7 @@ def test_base_url_env(self) -> None: ], ids=["standard", "custom http client"], ) - def test_base_url_trailing_slash(self, client: AgentexSDK) -> None: + def test_base_url_trailing_slash(self, client: Agentex) -> None: request = client._build_request( FinalRequestOptions( method="post", @@ -597,10 +593,8 @@ def test_base_url_trailing_slash(self, client: AgentexSDK) -> None: @pytest.mark.parametrize( "client", [ - AgentexSDK( - base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True - ), - AgentexSDK( + Agentex(base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True), + Agentex( base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True, @@ -609,7 +603,7 @@ def test_base_url_trailing_slash(self, client: AgentexSDK) -> None: ], ids=["standard", "custom http client"], ) - def test_base_url_no_trailing_slash(self, client: AgentexSDK) -> None: + def test_base_url_no_trailing_slash(self, client: Agentex) -> None: request = client._build_request( FinalRequestOptions( method="post", @@ -622,10 +616,8 @@ def test_base_url_no_trailing_slash(self, client: AgentexSDK) -> None: @pytest.mark.parametrize( "client", [ - AgentexSDK( - base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True - ), - AgentexSDK( + Agentex(base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True), + Agentex( base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True, @@ -634,7 +626,7 @@ def test_base_url_no_trailing_slash(self, client: AgentexSDK) -> None: ], ids=["standard", "custom http client"], ) - def test_absolute_request_url(self, client: AgentexSDK) -> None: + def test_absolute_request_url(self, client: Agentex) -> None: request = client._build_request( FinalRequestOptions( method="post", @@ -645,7 +637,7 @@ def test_absolute_request_url(self, client: AgentexSDK) -> None: assert request.url == "https://myapi.com/foo" def test_copied_client_does_not_close_http(self) -> None: - client = AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) assert not client.is_closed() copied = client.copy() @@ -656,7 +648,7 @@ def test_copied_client_does_not_close_http(self) -> None: assert not client.is_closed() def test_client_context_manager(self) -> None: - client = AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) with client as c2: assert c2 is client assert not c2.is_closed() @@ -677,9 +669,7 @@ class Model(BaseModel): def test_client_max_retries_validation(self) -> None: with pytest.raises(TypeError, match=r"max_retries cannot be None"): - AgentexSDK( - base_url=base_url, api_key=api_key, _strict_response_validation=True, max_retries=cast(Any, None) - ) + Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True, max_retries=cast(Any, None)) @pytest.mark.respx(base_url=base_url) def test_received_text_for_expected_json(self, respx_mock: MockRouter) -> None: @@ -688,12 +678,12 @@ class Model(BaseModel): respx_mock.get("/foo").mock(return_value=httpx.Response(200, text="my-custom-format")) - strict_client = AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + strict_client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) with pytest.raises(APIResponseValidationError): strict_client.get("/foo", cast_to=Model) - client = AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=False) + client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=False) response = client.get("/foo", cast_to=Model) assert isinstance(response, str) # type: ignore[unreachable] @@ -721,7 +711,7 @@ class Model(BaseModel): ) @mock.patch("time.time", mock.MagicMock(return_value=1696004797)) def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str, timeout: float) -> None: - client = AgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) headers = httpx.Headers({"retry-after": retry_after}) options = FinalRequestOptions(method="get", url="/foo", max_retries=3) @@ -730,7 +720,7 @@ def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) - def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter, client: AgentexSDK) -> None: + def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter, client: Agentex) -> None: respx_mock.post("/echo").mock(side_effect=httpx.TimeoutException("Test timeout error")) with pytest.raises(APITimeoutError): @@ -740,7 +730,7 @@ def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter, clien @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) - def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, client: AgentexSDK) -> None: + def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, client: Agentex) -> None: respx_mock.post("/echo").mock(return_value=httpx.Response(500)) with pytest.raises(APIStatusError): @@ -753,7 +743,7 @@ def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, client @pytest.mark.parametrize("failure_mode", ["status", "exception"]) def test_retries_taken( self, - client: AgentexSDK, + client: Agentex, failures_before_success: int, failure_mode: Literal["status", "exception"], respx_mock: MockRouter, @@ -782,7 +772,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) def test_omit_retry_count_header( - self, client: AgentexSDK, failures_before_success: int, respx_mock: MockRouter + self, client: Agentex, failures_before_success: int, respx_mock: MockRouter ) -> None: client = client.with_options(max_retries=4) @@ -807,7 +797,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) def test_overwrite_retry_count_header( - self, client: AgentexSDK, failures_before_success: int, respx_mock: MockRouter + self, client: Agentex, failures_before_success: int, respx_mock: MockRouter ) -> None: client = client.with_options(max_retries=4) @@ -878,8 +868,8 @@ def test_follow_redirects_disabled(self, respx_mock: MockRouter) -> None: assert exc_info.value.response.headers["Location"] == f"{base_url}/redirected" -class TestAsyncAgentexSDK: - client = AsyncAgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) +class TestAsyncAgentex: + client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) @pytest.mark.respx(base_url=base_url) @pytest.mark.asyncio @@ -928,7 +918,7 @@ def test_copy_default_options(self) -> None: assert isinstance(self.client.timeout, httpx.Timeout) def test_copy_default_headers(self) -> None: - client = AsyncAgentexSDK( + client = AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} ) assert client.default_headers["X-Foo"] == "bar" @@ -962,7 +952,7 @@ def test_copy_default_headers(self) -> None: client.copy(set_default_headers={}, default_headers={"X-Foo": "Bar"}) def test_copy_default_query(self) -> None: - client = AsyncAgentexSDK( + client = AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"foo": "bar"} ) assert _get_params(client)["foo"] == "bar" @@ -1088,7 +1078,7 @@ async def test_request_timeout(self) -> None: assert timeout == httpx.Timeout(100.0) async def test_client_timeout_option(self) -> None: - client = AsyncAgentexSDK( + client = AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, timeout=httpx.Timeout(0) ) @@ -1099,7 +1089,7 @@ async def test_client_timeout_option(self) -> None: async def test_http_client_timeout_option(self) -> None: # custom timeout given to the httpx client should be used async with httpx.AsyncClient(timeout=None) as http_client: - client = AsyncAgentexSDK( + client = AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client ) @@ -1109,7 +1099,7 @@ async def test_http_client_timeout_option(self) -> None: # no timeout given to the httpx client should not use the httpx default async with httpx.AsyncClient() as http_client: - client = AsyncAgentexSDK( + client = AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client ) @@ -1119,7 +1109,7 @@ async def test_http_client_timeout_option(self) -> None: # explicitly passing the default timeout currently results in it being ignored async with httpx.AsyncClient(timeout=HTTPX_DEFAULT_TIMEOUT) as http_client: - client = AsyncAgentexSDK( + client = AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client ) @@ -1130,7 +1120,7 @@ async def test_http_client_timeout_option(self) -> None: def test_invalid_http_client(self) -> None: with pytest.raises(TypeError, match="Invalid `http_client` arg"): with httpx.Client() as http_client: - AsyncAgentexSDK( + AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, @@ -1138,14 +1128,14 @@ def test_invalid_http_client(self) -> None: ) def test_default_headers_option(self) -> None: - client = AsyncAgentexSDK( + client = AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} ) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) assert request.headers.get("x-foo") == "bar" assert request.headers.get("x-stainless-lang") == "python" - client2 = AsyncAgentexSDK( + client2 = AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, @@ -1159,12 +1149,12 @@ def test_default_headers_option(self) -> None: assert request.headers.get("x-stainless-lang") == "my-overriding-header" def test_validate_headers(self) -> None: - client = AsyncAgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) assert request.headers.get("Authorization") == f"Bearer {api_key}" with update_env(**{"AGENTEX_SDK_API_KEY": Omit()}): - client2 = AsyncAgentexSDK(base_url=base_url, api_key=None, _strict_response_validation=True) + client2 = AsyncAgentex(base_url=base_url, api_key=None, _strict_response_validation=True) with pytest.raises( TypeError, @@ -1178,7 +1168,7 @@ def test_validate_headers(self) -> None: assert request2.headers.get("Authorization") is None def test_default_query_option(self) -> None: - client = AsyncAgentexSDK( + client = AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"query_param": "bar"} ) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) @@ -1292,7 +1282,7 @@ def test_request_extra_query(self) -> None: params = dict(request.url.params) assert params == {"foo": "2"} - def test_multipart_repeating_array(self, async_client: AsyncAgentexSDK) -> None: + def test_multipart_repeating_array(self, async_client: AsyncAgentex) -> None: request = async_client._build_request( FinalRequestOptions.construct( method="post", @@ -1379,7 +1369,7 @@ class Model(BaseModel): assert response.foo == 2 def test_base_url_setter(self) -> None: - client = AsyncAgentexSDK( + client = AsyncAgentex( base_url="https://example.com/from_init", api_key=api_key, _strict_response_validation=True ) assert client.base_url == "https://example.com/from_init/" @@ -1389,17 +1379,17 @@ def test_base_url_setter(self) -> None: assert client.base_url == "https://example.com/from_setter/" def test_base_url_env(self) -> None: - with update_env(AGENTEX_SDK_BASE_URL="http://localhost:5000/from/env"): - client = AsyncAgentexSDK(api_key=api_key, _strict_response_validation=True) + with update_env(AGENTEX_BASE_URL="http://localhost:5000/from/env"): + client = AsyncAgentex(api_key=api_key, _strict_response_validation=True) assert client.base_url == "http://localhost:5000/from/env/" @pytest.mark.parametrize( "client", [ - AsyncAgentexSDK( + AsyncAgentex( base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True ), - AsyncAgentexSDK( + AsyncAgentex( base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True, @@ -1408,7 +1398,7 @@ def test_base_url_env(self) -> None: ], ids=["standard", "custom http client"], ) - def test_base_url_trailing_slash(self, client: AsyncAgentexSDK) -> None: + def test_base_url_trailing_slash(self, client: AsyncAgentex) -> None: request = client._build_request( FinalRequestOptions( method="post", @@ -1421,10 +1411,10 @@ def test_base_url_trailing_slash(self, client: AsyncAgentexSDK) -> None: @pytest.mark.parametrize( "client", [ - AsyncAgentexSDK( + AsyncAgentex( base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True ), - AsyncAgentexSDK( + AsyncAgentex( base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True, @@ -1433,7 +1423,7 @@ def test_base_url_trailing_slash(self, client: AsyncAgentexSDK) -> None: ], ids=["standard", "custom http client"], ) - def test_base_url_no_trailing_slash(self, client: AsyncAgentexSDK) -> None: + def test_base_url_no_trailing_slash(self, client: AsyncAgentex) -> None: request = client._build_request( FinalRequestOptions( method="post", @@ -1446,10 +1436,10 @@ def test_base_url_no_trailing_slash(self, client: AsyncAgentexSDK) -> None: @pytest.mark.parametrize( "client", [ - AsyncAgentexSDK( + AsyncAgentex( base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True ), - AsyncAgentexSDK( + AsyncAgentex( base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True, @@ -1458,7 +1448,7 @@ def test_base_url_no_trailing_slash(self, client: AsyncAgentexSDK) -> None: ], ids=["standard", "custom http client"], ) - def test_absolute_request_url(self, client: AsyncAgentexSDK) -> None: + def test_absolute_request_url(self, client: AsyncAgentex) -> None: request = client._build_request( FinalRequestOptions( method="post", @@ -1469,7 +1459,7 @@ def test_absolute_request_url(self, client: AsyncAgentexSDK) -> None: assert request.url == "https://myapi.com/foo" async def test_copied_client_does_not_close_http(self) -> None: - client = AsyncAgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) assert not client.is_closed() copied = client.copy() @@ -1481,7 +1471,7 @@ async def test_copied_client_does_not_close_http(self) -> None: assert not client.is_closed() async def test_client_context_manager(self) -> None: - client = AsyncAgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) async with client as c2: assert c2 is client assert not c2.is_closed() @@ -1503,7 +1493,7 @@ class Model(BaseModel): async def test_client_max_retries_validation(self) -> None: with pytest.raises(TypeError, match=r"max_retries cannot be None"): - AsyncAgentexSDK( + AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, max_retries=cast(Any, None) ) @@ -1515,12 +1505,12 @@ class Model(BaseModel): respx_mock.get("/foo").mock(return_value=httpx.Response(200, text="my-custom-format")) - strict_client = AsyncAgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + strict_client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) with pytest.raises(APIResponseValidationError): await strict_client.get("/foo", cast_to=Model) - client = AsyncAgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=False) + client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=False) response = await client.get("/foo", cast_to=Model) assert isinstance(response, str) # type: ignore[unreachable] @@ -1549,7 +1539,7 @@ class Model(BaseModel): @mock.patch("time.time", mock.MagicMock(return_value=1696004797)) @pytest.mark.asyncio async def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str, timeout: float) -> None: - client = AsyncAgentexSDK(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) headers = httpx.Headers({"retry-after": retry_after}) options = FinalRequestOptions(method="get", url="/foo", max_retries=3) @@ -1559,7 +1549,7 @@ async def test_parse_retry_after_header(self, remaining_retries: int, retry_afte @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) async def test_retrying_timeout_errors_doesnt_leak( - self, respx_mock: MockRouter, async_client: AsyncAgentexSDK + self, respx_mock: MockRouter, async_client: AsyncAgentex ) -> None: respx_mock.post("/echo").mock(side_effect=httpx.TimeoutException("Test timeout error")) @@ -1570,9 +1560,7 @@ async def test_retrying_timeout_errors_doesnt_leak( @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) - async def test_retrying_status_errors_doesnt_leak( - self, respx_mock: MockRouter, async_client: AsyncAgentexSDK - ) -> None: + async def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, async_client: AsyncAgentex) -> None: respx_mock.post("/echo").mock(return_value=httpx.Response(500)) with pytest.raises(APIStatusError): @@ -1586,7 +1574,7 @@ async def test_retrying_status_errors_doesnt_leak( @pytest.mark.parametrize("failure_mode", ["status", "exception"]) async def test_retries_taken( self, - async_client: AsyncAgentexSDK, + async_client: AsyncAgentex, failures_before_success: int, failure_mode: Literal["status", "exception"], respx_mock: MockRouter, @@ -1616,7 +1604,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: @pytest.mark.respx(base_url=base_url) @pytest.mark.asyncio async def test_omit_retry_count_header( - self, async_client: AsyncAgentexSDK, failures_before_success: int, respx_mock: MockRouter + self, async_client: AsyncAgentex, failures_before_success: int, respx_mock: MockRouter ) -> None: client = async_client.with_options(max_retries=4) @@ -1642,7 +1630,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: @pytest.mark.respx(base_url=base_url) @pytest.mark.asyncio async def test_overwrite_retry_count_header( - self, async_client: AsyncAgentexSDK, failures_before_success: int, respx_mock: MockRouter + self, async_client: AsyncAgentex, failures_before_success: int, respx_mock: MockRouter ) -> None: client = async_client.with_options(max_retries=4) diff --git a/tests/test_response.py b/tests/test_response.py index b8608700..ed94eb68 100644 --- a/tests/test_response.py +++ b/tests/test_response.py @@ -6,7 +6,7 @@ import pytest import pydantic -from agentex import BaseModel, AgentexSDK, AsyncAgentexSDK +from agentex import Agentex, BaseModel, AsyncAgentex from agentex._response import ( APIResponse, BaseAPIResponse, @@ -56,7 +56,7 @@ def test_extract_response_type_binary_response() -> None: class PydanticModel(pydantic.BaseModel): ... -def test_response_parse_mismatched_basemodel(client: AgentexSDK) -> None: +def test_response_parse_mismatched_basemodel(client: Agentex) -> None: response = APIResponse( raw=httpx.Response(200, content=b"foo"), client=client, @@ -74,7 +74,7 @@ def test_response_parse_mismatched_basemodel(client: AgentexSDK) -> None: @pytest.mark.asyncio -async def test_async_response_parse_mismatched_basemodel(async_client: AsyncAgentexSDK) -> None: +async def test_async_response_parse_mismatched_basemodel(async_client: AsyncAgentex) -> None: response = AsyncAPIResponse( raw=httpx.Response(200, content=b"foo"), client=async_client, @@ -91,7 +91,7 @@ async def test_async_response_parse_mismatched_basemodel(async_client: AsyncAgen await response.parse(to=PydanticModel) -def test_response_parse_custom_stream(client: AgentexSDK) -> None: +def test_response_parse_custom_stream(client: Agentex) -> None: response = APIResponse( raw=httpx.Response(200, content=b"foo"), client=client, @@ -106,7 +106,7 @@ def test_response_parse_custom_stream(client: AgentexSDK) -> None: @pytest.mark.asyncio -async def test_async_response_parse_custom_stream(async_client: AsyncAgentexSDK) -> None: +async def test_async_response_parse_custom_stream(async_client: AsyncAgentex) -> None: response = AsyncAPIResponse( raw=httpx.Response(200, content=b"foo"), client=async_client, @@ -125,7 +125,7 @@ class CustomModel(BaseModel): bar: int -def test_response_parse_custom_model(client: AgentexSDK) -> None: +def test_response_parse_custom_model(client: Agentex) -> None: response = APIResponse( raw=httpx.Response(200, content=json.dumps({"foo": "hello!", "bar": 2})), client=client, @@ -141,7 +141,7 @@ def test_response_parse_custom_model(client: AgentexSDK) -> None: @pytest.mark.asyncio -async def test_async_response_parse_custom_model(async_client: AsyncAgentexSDK) -> None: +async def test_async_response_parse_custom_model(async_client: AsyncAgentex) -> None: response = AsyncAPIResponse( raw=httpx.Response(200, content=json.dumps({"foo": "hello!", "bar": 2})), client=async_client, @@ -156,7 +156,7 @@ async def test_async_response_parse_custom_model(async_client: AsyncAgentexSDK) assert obj.bar == 2 -def test_response_parse_annotated_type(client: AgentexSDK) -> None: +def test_response_parse_annotated_type(client: Agentex) -> None: response = APIResponse( raw=httpx.Response(200, content=json.dumps({"foo": "hello!", "bar": 2})), client=client, @@ -173,7 +173,7 @@ def test_response_parse_annotated_type(client: AgentexSDK) -> None: assert obj.bar == 2 -async def test_async_response_parse_annotated_type(async_client: AsyncAgentexSDK) -> None: +async def test_async_response_parse_annotated_type(async_client: AsyncAgentex) -> None: response = AsyncAPIResponse( raw=httpx.Response(200, content=json.dumps({"foo": "hello!", "bar": 2})), client=async_client, @@ -201,7 +201,7 @@ async def test_async_response_parse_annotated_type(async_client: AsyncAgentexSDK ("FalSe", False), ], ) -def test_response_parse_bool(client: AgentexSDK, content: str, expected: bool) -> None: +def test_response_parse_bool(client: Agentex, content: str, expected: bool) -> None: response = APIResponse( raw=httpx.Response(200, content=content), client=client, @@ -226,7 +226,7 @@ def test_response_parse_bool(client: AgentexSDK, content: str, expected: bool) - ("FalSe", False), ], ) -async def test_async_response_parse_bool(client: AsyncAgentexSDK, content: str, expected: bool) -> None: +async def test_async_response_parse_bool(client: AsyncAgentex, content: str, expected: bool) -> None: response = AsyncAPIResponse( raw=httpx.Response(200, content=content), client=client, @@ -245,7 +245,7 @@ class OtherModel(BaseModel): @pytest.mark.parametrize("client", [False], indirect=True) # loose validation -def test_response_parse_expect_model_union_non_json_content(client: AgentexSDK) -> None: +def test_response_parse_expect_model_union_non_json_content(client: Agentex) -> None: response = APIResponse( raw=httpx.Response(200, content=b"foo", headers={"Content-Type": "application/text"}), client=client, @@ -262,7 +262,7 @@ def test_response_parse_expect_model_union_non_json_content(client: AgentexSDK) @pytest.mark.asyncio @pytest.mark.parametrize("async_client", [False], indirect=True) # loose validation -async def test_async_response_parse_expect_model_union_non_json_content(async_client: AsyncAgentexSDK) -> None: +async def test_async_response_parse_expect_model_union_non_json_content(async_client: AsyncAgentex) -> None: response = AsyncAPIResponse( raw=httpx.Response(200, content=b"foo", headers={"Content-Type": "application/text"}), client=async_client, diff --git a/tests/test_streaming.py b/tests/test_streaming.py index aa5b8003..4b6a392d 100644 --- a/tests/test_streaming.py +++ b/tests/test_streaming.py @@ -5,13 +5,13 @@ import httpx import pytest -from agentex import AgentexSDK, AsyncAgentexSDK +from agentex import Agentex, AsyncAgentex from agentex._streaming import Stream, AsyncStream, ServerSentEvent @pytest.mark.asyncio @pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) -async def test_basic(sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK) -> None: +async def test_basic(sync: bool, client: Agentex, async_client: AsyncAgentex) -> None: def body() -> Iterator[bytes]: yield b"event: completion\n" yield b'data: {"foo":true}\n' @@ -28,7 +28,7 @@ def body() -> Iterator[bytes]: @pytest.mark.asyncio @pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) -async def test_data_missing_event(sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK) -> None: +async def test_data_missing_event(sync: bool, client: Agentex, async_client: AsyncAgentex) -> None: def body() -> Iterator[bytes]: yield b'data: {"foo":true}\n' yield b"\n" @@ -44,7 +44,7 @@ def body() -> Iterator[bytes]: @pytest.mark.asyncio @pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) -async def test_event_missing_data(sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK) -> None: +async def test_event_missing_data(sync: bool, client: Agentex, async_client: AsyncAgentex) -> None: def body() -> Iterator[bytes]: yield b"event: ping\n" yield b"\n" @@ -60,7 +60,7 @@ def body() -> Iterator[bytes]: @pytest.mark.asyncio @pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) -async def test_multiple_events(sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK) -> None: +async def test_multiple_events(sync: bool, client: Agentex, async_client: AsyncAgentex) -> None: def body() -> Iterator[bytes]: yield b"event: ping\n" yield b"\n" @@ -82,7 +82,7 @@ def body() -> Iterator[bytes]: @pytest.mark.asyncio @pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) -async def test_multiple_events_with_data(sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK) -> None: +async def test_multiple_events_with_data(sync: bool, client: Agentex, async_client: AsyncAgentex) -> None: def body() -> Iterator[bytes]: yield b"event: ping\n" yield b'data: {"foo":true}\n' @@ -106,9 +106,7 @@ def body() -> Iterator[bytes]: @pytest.mark.asyncio @pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) -async def test_multiple_data_lines_with_empty_line( - sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK -) -> None: +async def test_multiple_data_lines_with_empty_line(sync: bool, client: Agentex, async_client: AsyncAgentex) -> None: def body() -> Iterator[bytes]: yield b"event: ping\n" yield b"data: {\n" @@ -130,7 +128,7 @@ def body() -> Iterator[bytes]: @pytest.mark.asyncio @pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) -async def test_data_json_escaped_double_new_line(sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK) -> None: +async def test_data_json_escaped_double_new_line(sync: bool, client: Agentex, async_client: AsyncAgentex) -> None: def body() -> Iterator[bytes]: yield b"event: ping\n" yield b'data: {"foo": "my long\\n\\ncontent"}' @@ -147,7 +145,7 @@ def body() -> Iterator[bytes]: @pytest.mark.asyncio @pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) -async def test_multiple_data_lines(sync: bool, client: AgentexSDK, async_client: AsyncAgentexSDK) -> None: +async def test_multiple_data_lines(sync: bool, client: Agentex, async_client: AsyncAgentex) -> None: def body() -> Iterator[bytes]: yield b"event: ping\n" yield b"data: {\n" @@ -167,8 +165,8 @@ def body() -> Iterator[bytes]: @pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) async def test_special_new_line_character( sync: bool, - client: AgentexSDK, - async_client: AsyncAgentexSDK, + client: Agentex, + async_client: AsyncAgentex, ) -> None: def body() -> Iterator[bytes]: yield b'data: {"content":" culpa"}\n' @@ -198,8 +196,8 @@ def body() -> Iterator[bytes]: @pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"]) async def test_multi_byte_character_multiple_chunks( sync: bool, - client: AgentexSDK, - async_client: AsyncAgentexSDK, + client: Agentex, + async_client: AsyncAgentex, ) -> None: def body() -> Iterator[bytes]: yield b'data: {"content":"' @@ -239,8 +237,8 @@ def make_event_iterator( content: Iterator[bytes], *, sync: bool, - client: AgentexSDK, - async_client: AsyncAgentexSDK, + client: Agentex, + async_client: AsyncAgentex, ) -> Iterator[ServerSentEvent] | AsyncIterator[ServerSentEvent]: if sync: return Stream(cast_to=object, client=client, response=httpx.Response(200, content=content))._iter_events() From b513a8a7ed319a246cfa771916a078b3583c7afa Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 18 Jul 2025 18:14:13 +0000 Subject: [PATCH 0014/1108] feat(api): manual updates --- .stats.yml | 2 +- api.md | 2 +- src/agentex/types/__init__.py | 1 - src/agentex/types/agent_rpc_params.py | 21 +++++++++++++-- src/agentex/types/agents/name_rpc_params.py | 21 +++++++++++++-- src/agentex/types/send_event_request_param.py | 26 ------------------- 6 files changed, 40 insertions(+), 33 deletions(-) delete mode 100644 src/agentex/types/send_event_request_param.py diff --git a/.stats.yml b/.stats.yml index 633be9e4..367d71d9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 36 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-e8ce15a00ebbfb8be199c0172a95616741cb872a8d346bd039cdde45153ec79c.yml openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 -config_hash: 34ee931ef475bb5c3697d8a920a13f22 +config_hash: 93faf4082abdf844f4cdb26bb393604d diff --git a/api.md b/api.md index 693e4ae5..45be6a64 100644 --- a/api.md +++ b/api.md @@ -15,7 +15,7 @@ Methods: Types: ```python -from agentex.types import AcpType, Agent, AgentRpcRequest, SendEventRequest, AgentListResponse +from agentex.types import AcpType, Agent, AgentRpcRequest, AgentListResponse ``` Methods: diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 9a11ae34..17dc3aa2 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -41,6 +41,5 @@ from .tool_response_content import ToolResponseContent as ToolResponseContent from .tracker_list_response import TrackerListResponse as TrackerListResponse from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams -from .send_event_request_param import SendEventRequestParam as SendEventRequestParam from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam diff --git a/src/agentex/types/agent_rpc_params.py b/src/agentex/types/agent_rpc_params.py index 89dbdca0..2c79a7a9 100644 --- a/src/agentex/types/agent_rpc_params.py +++ b/src/agentex/types/agent_rpc_params.py @@ -7,7 +7,6 @@ from .data_content_param import DataContentParam from .text_content_param import TextContentParam -from .send_event_request_param import SendEventRequestParam from .tool_request_content_param import ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam @@ -18,6 +17,8 @@ "ParamsCancelTaskRequest", "ParamsSendMessageRequest", "ParamsSendMessageRequestContent", + "ParamsSendEventRequest", + "ParamsSendEventRequestContent", ] @@ -63,6 +64,22 @@ class ParamsSendMessageRequest(TypedDict, total=False): """The ID of the task that the message was sent to""" +ParamsSendEventRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendEventRequest(TypedDict, total=False): + content: Optional[ParamsSendEventRequestContent] + """The content to send to the event""" + + task_id: Optional[str] + """The ID of the task that the event was sent to""" + + task_name: Optional[str] + """The name of the task that the event was sent to""" + + Params: TypeAlias = Union[ - ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, SendEventRequestParam + ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest ] diff --git a/src/agentex/types/agents/name_rpc_params.py b/src/agentex/types/agents/name_rpc_params.py index 590710c3..6a68b0ba 100644 --- a/src/agentex/types/agents/name_rpc_params.py +++ b/src/agentex/types/agents/name_rpc_params.py @@ -7,7 +7,6 @@ from ..data_content_param import DataContentParam from ..text_content_param import TextContentParam -from ..send_event_request_param import SendEventRequestParam from ..tool_request_content_param import ToolRequestContentParam from ..tool_response_content_param import ToolResponseContentParam @@ -18,6 +17,8 @@ "ParamsCancelTaskRequest", "ParamsSendMessageRequest", "ParamsSendMessageRequestContent", + "ParamsSendEventRequest", + "ParamsSendEventRequestContent", ] @@ -63,6 +64,22 @@ class ParamsSendMessageRequest(TypedDict, total=False): """The ID of the task that the message was sent to""" +ParamsSendEventRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendEventRequest(TypedDict, total=False): + content: Optional[ParamsSendEventRequestContent] + """The content to send to the event""" + + task_id: Optional[str] + """The ID of the task that the event was sent to""" + + task_name: Optional[str] + """The name of the task that the event was sent to""" + + Params: TypeAlias = Union[ - ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, SendEventRequestParam + ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest ] diff --git a/src/agentex/types/send_event_request_param.py b/src/agentex/types/send_event_request_param.py deleted file mode 100644 index e1142a7b..00000000 --- a/src/agentex/types/send_event_request_param.py +++ /dev/null @@ -1,26 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Union, Optional -from typing_extensions import TypeAlias, TypedDict - -from .data_content_param import DataContentParam -from .text_content_param import TextContentParam -from .tool_request_content_param import ToolRequestContentParam -from .tool_response_content_param import ToolResponseContentParam - -__all__ = ["SendEventRequestParam", "Content"] - -Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] - - -class SendEventRequestParam(TypedDict, total=False): - content: Optional[Content] - """The content to send to the event""" - - task_id: Optional[str] - """The ID of the task that the event was sent to""" - - task_name: Optional[str] - """The name of the task that the event was sent to""" From d51f85901c0d839b71e98e9bbf3ca68a006bdd80 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 18 Jul 2025 18:44:53 +0000 Subject: [PATCH 0015/1108] feat(api): manual updates --- .stats.yml | 4 ++-- src/agentex/resources/agents/agents.py | 4 ++++ src/agentex/resources/agents/name.py | 4 ++++ src/agentex/types/agent_rpc_params.py | 1 + src/agentex/types/agents/name_rpc_params.py | 1 + 5 files changed, 12 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 367d71d9..c18a93b8 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 36 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-e8ce15a00ebbfb8be199c0172a95616741cb872a8d346bd039cdde45153ec79c.yml -openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6f399049a92986ebf981b48a83e8d10b7c37719cee5e64880331389b9f70b021.yml +openapi_spec_hash: ebcb8fadda5e777f4d67aa0334db7257 config_hash: 93faf4082abdf844f4cdb26bb393604d diff --git a/src/agentex/resources/agents/agents.py b/src/agentex/resources/agents/agents.py index b6a49a76..5d8cab08 100644 --- a/src/agentex/resources/agents/agents.py +++ b/src/agentex/resources/agents/agents.py @@ -179,6 +179,8 @@ def rpc( Handle JSON-RPC requests for an agent by its unique ID. Args: + params: The parameters for the agent RPC request + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -353,6 +355,8 @@ async def rpc( Handle JSON-RPC requests for an agent by its unique ID. Args: + params: The parameters for the agent RPC request + extra_headers: Send extra headers extra_query: Add additional query parameters to the request diff --git a/src/agentex/resources/agents/name.py b/src/agentex/resources/agents/name.py index a386d7fd..ef99053b 100644 --- a/src/agentex/resources/agents/name.py +++ b/src/agentex/resources/agents/name.py @@ -129,6 +129,8 @@ def rpc( Handle JSON-RPC requests for an agent by its unique name. Args: + params: The parameters for the agent RPC request + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -262,6 +264,8 @@ async def rpc( Handle JSON-RPC requests for an agent by its unique name. Args: + params: The parameters for the agent RPC request + extra_headers: Send extra headers extra_query: Add additional query parameters to the request diff --git a/src/agentex/types/agent_rpc_params.py b/src/agentex/types/agent_rpc_params.py index 2c79a7a9..4e83e75f 100644 --- a/src/agentex/types/agent_rpc_params.py +++ b/src/agentex/types/agent_rpc_params.py @@ -26,6 +26,7 @@ class AgentRpcParams(TypedDict, total=False): method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] params: Required[Params] + """The parameters for the agent RPC request""" id: Union[int, str, None] diff --git a/src/agentex/types/agents/name_rpc_params.py b/src/agentex/types/agents/name_rpc_params.py index 6a68b0ba..5ebbf70c 100644 --- a/src/agentex/types/agents/name_rpc_params.py +++ b/src/agentex/types/agents/name_rpc_params.py @@ -26,6 +26,7 @@ class NameRpcParams(TypedDict, total=False): method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] params: Required[Params] + """The parameters for the agent RPC request""" id: Union[int, str, None] From 413d5192ef538b69f4c20eaaed83de35ad6d231b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 18 Jul 2025 19:23:47 +0000 Subject: [PATCH 0016/1108] feat(api): api update --- .stats.yml | 4 ++-- src/agentex/resources/agents/agents.py | 4 ---- src/agentex/resources/agents/name.py | 4 ---- src/agentex/types/agent_rpc_params.py | 1 - src/agentex/types/agents/name_rpc_params.py | 1 - 5 files changed, 2 insertions(+), 12 deletions(-) diff --git a/.stats.yml b/.stats.yml index c18a93b8..367d71d9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 36 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6f399049a92986ebf981b48a83e8d10b7c37719cee5e64880331389b9f70b021.yml -openapi_spec_hash: ebcb8fadda5e777f4d67aa0334db7257 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-e8ce15a00ebbfb8be199c0172a95616741cb872a8d346bd039cdde45153ec79c.yml +openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 config_hash: 93faf4082abdf844f4cdb26bb393604d diff --git a/src/agentex/resources/agents/agents.py b/src/agentex/resources/agents/agents.py index 5d8cab08..b6a49a76 100644 --- a/src/agentex/resources/agents/agents.py +++ b/src/agentex/resources/agents/agents.py @@ -179,8 +179,6 @@ def rpc( Handle JSON-RPC requests for an agent by its unique ID. Args: - params: The parameters for the agent RPC request - extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -355,8 +353,6 @@ async def rpc( Handle JSON-RPC requests for an agent by its unique ID. Args: - params: The parameters for the agent RPC request - extra_headers: Send extra headers extra_query: Add additional query parameters to the request diff --git a/src/agentex/resources/agents/name.py b/src/agentex/resources/agents/name.py index ef99053b..a386d7fd 100644 --- a/src/agentex/resources/agents/name.py +++ b/src/agentex/resources/agents/name.py @@ -129,8 +129,6 @@ def rpc( Handle JSON-RPC requests for an agent by its unique name. Args: - params: The parameters for the agent RPC request - extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -264,8 +262,6 @@ async def rpc( Handle JSON-RPC requests for an agent by its unique name. Args: - params: The parameters for the agent RPC request - extra_headers: Send extra headers extra_query: Add additional query parameters to the request diff --git a/src/agentex/types/agent_rpc_params.py b/src/agentex/types/agent_rpc_params.py index 4e83e75f..2c79a7a9 100644 --- a/src/agentex/types/agent_rpc_params.py +++ b/src/agentex/types/agent_rpc_params.py @@ -26,7 +26,6 @@ class AgentRpcParams(TypedDict, total=False): method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] params: Required[Params] - """The parameters for the agent RPC request""" id: Union[int, str, None] diff --git a/src/agentex/types/agents/name_rpc_params.py b/src/agentex/types/agents/name_rpc_params.py index 5ebbf70c..6a68b0ba 100644 --- a/src/agentex/types/agents/name_rpc_params.py +++ b/src/agentex/types/agents/name_rpc_params.py @@ -26,7 +26,6 @@ class NameRpcParams(TypedDict, total=False): method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] params: Required[Params] - """The parameters for the agent RPC request""" id: Union[int, str, None] From 0ef75521d1d56c1388641cb8efb53851394dffce Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 18 Jul 2025 20:48:22 +0000 Subject: [PATCH 0017/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 367d71d9..7461a9cd 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 36 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-e8ce15a00ebbfb8be199c0172a95616741cb872a8d346bd039cdde45153ec79c.yml +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c5467b01c2ccad0693f5965a431eea9a48204aa3e3ab0dca8b5c5d96dfdb5b3b.yml openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 -config_hash: 93faf4082abdf844f4cdb26bb393604d +config_hash: cf7785ffd5ef918f091d0f20a36c9bba From eecb7fa5e3f98139934ad164b3ca86f792c00a12 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 21 Jul 2025 12:27:40 +0000 Subject: [PATCH 0018/1108] fix(parsing): ignore empty metadata --- src/agentex/_models.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/agentex/_models.py b/src/agentex/_models.py index 528d5680..ffcbf67b 100644 --- a/src/agentex/_models.py +++ b/src/agentex/_models.py @@ -439,7 +439,7 @@ def construct_type(*, value: object, type_: object, metadata: Optional[List[Any] type_ = type_.__value__ # type: ignore[unreachable] # unwrap `Annotated[T, ...]` -> `T` - if metadata is not None: + if metadata is not None and len(metadata) > 0: meta: tuple[Any, ...] = tuple(metadata) elif is_annotated_type(type_): meta = get_args(type_)[1:] From c76e897bf07d9eca93691038dfa7d9af81a3d7e4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 21 Jul 2025 21:58:32 +0000 Subject: [PATCH 0019/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 7461a9cd..ecb3dcc8 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 36 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c5467b01c2ccad0693f5965a431eea9a48204aa3e3ab0dca8b5c5d96dfdb5b3b.yml +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-021b55c88964b7a5bfc9d692d32a52c6b0150445656d2407c4cb8e9dd1e5f100.yml openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 -config_hash: cf7785ffd5ef918f091d0f20a36c9bba +config_hash: 8538b55df2781bbda1bc8f1b5c16bea3 From 81ab75e3b56451007ce9f2f524e4cd4f1ad6cc08 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 22 Jul 2025 01:14:55 +0000 Subject: [PATCH 0020/1108] chore: update SDK settings --- .github/workflows/publish-pypi.yml | 31 ++++++++++ .github/workflows/release-doctor.yml | 21 +++++++ .release-please-manifest.json | 3 + .stats.yml | 2 +- CONTRIBUTING.md | 4 +- README.md | 14 ++--- bin/check-release-environment | 21 +++++++ pyproject.toml | 6 +- release-please-config.json | 66 ++++++++++++++++++++++ src/agentex/_version.py | 2 +- src/agentex/resources/agents/agents.py | 8 +-- src/agentex/resources/agents/name.py | 8 +-- src/agentex/resources/echo.py | 8 +-- src/agentex/resources/events.py | 8 +-- src/agentex/resources/messages/batch.py | 8 +-- src/agentex/resources/messages/messages.py | 8 +-- src/agentex/resources/spans.py | 8 +-- src/agentex/resources/states.py | 8 +-- src/agentex/resources/tasks/name.py | 8 +-- src/agentex/resources/tasks/tasks.py | 8 +-- src/agentex/resources/tracker.py | 8 +-- 21 files changed, 200 insertions(+), 58 deletions(-) create mode 100644 .github/workflows/publish-pypi.yml create mode 100644 .github/workflows/release-doctor.yml create mode 100644 .release-please-manifest.json create mode 100644 bin/check-release-environment create mode 100644 release-please-config.json diff --git a/.github/workflows/publish-pypi.yml b/.github/workflows/publish-pypi.yml new file mode 100644 index 00000000..7e8ac3bd --- /dev/null +++ b/.github/workflows/publish-pypi.yml @@ -0,0 +1,31 @@ +# This workflow is triggered when a GitHub release is created. +# It can also be run manually to re-publish to PyPI in case it failed for some reason. +# You can run this workflow by navigating to https://www.github.com/scaleapi/agentex-python/actions/workflows/publish-pypi.yml +name: Publish PyPI +on: + workflow_dispatch: + + release: + types: [published] + +jobs: + publish: + name: publish + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + + - name: Install Rye + run: | + curl -sSf https://rye.astral.sh/get | bash + echo "$HOME/.rye/shims" >> $GITHUB_PATH + env: + RYE_VERSION: '0.44.0' + RYE_INSTALL_OPTION: '--yes' + + - name: Publish to PyPI + run: | + bash ./bin/publish-pypi + env: + PYPI_TOKEN: ${{ secrets.AGENTEX_PYPI_TOKEN || secrets.PYPI_TOKEN }} diff --git a/.github/workflows/release-doctor.yml b/.github/workflows/release-doctor.yml new file mode 100644 index 00000000..0521b7f6 --- /dev/null +++ b/.github/workflows/release-doctor.yml @@ -0,0 +1,21 @@ +name: Release Doctor +on: + pull_request: + branches: + - main + workflow_dispatch: + +jobs: + release_doctor: + name: release doctor + runs-on: ubuntu-latest + if: github.repository == 'scaleapi/agentex-python' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch' || startsWith(github.head_ref, 'release-please') || github.head_ref == 'next') + + steps: + - uses: actions/checkout@v4 + + - name: Check release environment + run: | + bash ./bin/check-release-environment + env: + PYPI_TOKEN: ${{ secrets.AGENTEX_PYPI_TOKEN || secrets.PYPI_TOKEN }} diff --git a/.release-please-manifest.json b/.release-please-manifest.json new file mode 100644 index 00000000..c4762802 --- /dev/null +++ b/.release-please-manifest.json @@ -0,0 +1,3 @@ +{ + ".": "0.0.1-alpha.0" +} \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index ecb3dcc8..fcb57dba 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 36 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-021b55c88964b7a5bfc9d692d32a52c6b0150445656d2407c4cb8e9dd1e5f100.yml openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 -config_hash: 8538b55df2781bbda1bc8f1b5c16bea3 +config_hash: 7da7819f4e997d293e02d83e7fd0aca7 diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 7b6c64be..305c811e 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -62,7 +62,7 @@ If you’d like to use the repository from source, you can either install from g To install via git: ```sh -$ pip install git+ssh://git@github.com/stainless-sdks/agentex-sdk-python.git +$ pip install git+ssh://git@github.com/scaleapi/agentex-python.git ``` Alternatively, you can build from source and install the wheel file: @@ -120,7 +120,7 @@ the changes aren't made through the automated pipeline, you may want to make rel ### Publish with a GitHub workflow -You can release to package managers by using [the `Publish PyPI` GitHub action](https://www.github.com/stainless-sdks/agentex-sdk-python/actions/workflows/publish-pypi.yml). This requires a setup organization or repository secret to be set up. +You can release to package managers by using [the `Publish PyPI` GitHub action](https://www.github.com/scaleapi/agentex-python/actions/workflows/publish-pypi.yml). This requires a setup organization or repository secret to be set up. ### Publish manually diff --git a/README.md b/README.md index 942f8a8d..db9c7afa 100644 --- a/README.md +++ b/README.md @@ -16,8 +16,8 @@ The full API of this library can be found in [api.md](api.md). ## Installation ```sh -# install from this staging repo -pip install git+ssh://git@github.com/stainless-sdks/agentex-sdk-python.git +# install from the production repo +pip install git+ssh://git@github.com/scaleapi/agentex-python.git ``` > [!NOTE] @@ -77,8 +77,8 @@ By default, the async client uses `httpx` for HTTP requests. However, for improv You can enable this by installing `aiohttp`: ```sh -# install from this staging repo -pip install 'agentex[aiohttp] @ git+ssh://git@github.com/stainless-sdks/agentex-sdk-python.git' +# install from the production repo +pip install 'agentex[aiohttp] @ git+ssh://git@github.com/scaleapi/agentex-python.git' ``` Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`: @@ -249,9 +249,9 @@ echo = response.parse() # get the object that `echo.send()` would have returned print(echo) ``` -These methods return an [`APIResponse`](https://github.com/stainless-sdks/agentex-sdk-python/tree/main/src/agentex/_response.py) object. +These methods return an [`APIResponse`](https://github.com/scaleapi/agentex-python/tree/main/src/agentex/_response.py) object. -The async client returns an [`AsyncAPIResponse`](https://github.com/stainless-sdks/agentex-sdk-python/tree/main/src/agentex/_response.py) with the same structure, the only difference being `await`able methods for reading the response content. +The async client returns an [`AsyncAPIResponse`](https://github.com/scaleapi/agentex-python/tree/main/src/agentex/_response.py) with the same structure, the only difference being `await`able methods for reading the response content. #### `.with_streaming_response` @@ -357,7 +357,7 @@ This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) con We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience. -We are keen for your feedback; please open an [issue](https://www.github.com/stainless-sdks/agentex-sdk-python/issues) with questions, bugs, or suggestions. +We are keen for your feedback; please open an [issue](https://www.github.com/scaleapi/agentex-python/issues) with questions, bugs, or suggestions. ### Determining the installed version diff --git a/bin/check-release-environment b/bin/check-release-environment new file mode 100644 index 00000000..b845b0f4 --- /dev/null +++ b/bin/check-release-environment @@ -0,0 +1,21 @@ +#!/usr/bin/env bash + +errors=() + +if [ -z "${PYPI_TOKEN}" ]; then + errors+=("The PYPI_TOKEN secret has not been set. Please set it in either this repository's secrets or your organization secrets.") +fi + +lenErrors=${#errors[@]} + +if [[ lenErrors -gt 0 ]]; then + echo -e "Found the following errors in the release environment:\n" + + for error in "${errors[@]}"; do + echo -e "- $error\n" + done + + exit 1 +fi + +echo "The environment is ready to push releases!" diff --git a/pyproject.toml b/pyproject.toml index dc089bdd..30ed0424 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -35,8 +35,8 @@ classifiers = [ ] [project.urls] -Homepage = "https://github.com/stainless-sdks/agentex-sdk-python" -Repository = "https://github.com/stainless-sdks/agentex-sdk-python" +Homepage = "https://github.com/scaleapi/agentex-python" +Repository = "https://github.com/scaleapi/agentex-python" [project.optional-dependencies] aiohttp = ["aiohttp", "httpx_aiohttp>=0.1.8"] @@ -125,7 +125,7 @@ path = "README.md" [[tool.hatch.metadata.hooks.fancy-pypi-readme.substitutions]] # replace relative links with absolute links pattern = '\[(.+?)\]\(((?!https?://)\S+?)\)' -replacement = '[\1](https://github.com/stainless-sdks/agentex-sdk-python/tree/main/\g<2>)' +replacement = '[\1](https://github.com/scaleapi/agentex-python/tree/main/\g<2>)' [tool.pytest.ini_options] testpaths = ["tests"] diff --git a/release-please-config.json b/release-please-config.json new file mode 100644 index 00000000..52d4c546 --- /dev/null +++ b/release-please-config.json @@ -0,0 +1,66 @@ +{ + "packages": { + ".": {} + }, + "$schema": "https://raw.githubusercontent.com/stainless-api/release-please/main/schemas/config.json", + "include-v-in-tag": true, + "include-component-in-tag": false, + "versioning": "prerelease", + "prerelease": true, + "bump-minor-pre-major": true, + "bump-patch-for-minor-pre-major": false, + "pull-request-header": "Automated Release PR", + "pull-request-title-pattern": "release: ${version}", + "changelog-sections": [ + { + "type": "feat", + "section": "Features" + }, + { + "type": "fix", + "section": "Bug Fixes" + }, + { + "type": "perf", + "section": "Performance Improvements" + }, + { + "type": "revert", + "section": "Reverts" + }, + { + "type": "chore", + "section": "Chores" + }, + { + "type": "docs", + "section": "Documentation" + }, + { + "type": "style", + "section": "Styles" + }, + { + "type": "refactor", + "section": "Refactors" + }, + { + "type": "test", + "section": "Tests", + "hidden": true + }, + { + "type": "build", + "section": "Build System" + }, + { + "type": "ci", + "section": "Continuous Integration", + "hidden": true + } + ], + "release-type": "python", + "extra-files": [ + "src/agentex/_version.py" + ] +} \ No newline at end of file diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 4c86089c..0e0636b8 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.0.1-alpha.0" +__version__ = "0.0.1-alpha.0" # x-release-please-version diff --git a/src/agentex/resources/agents/agents.py b/src/agentex/resources/agents/agents.py index b6a49a76..15b013d1 100644 --- a/src/agentex/resources/agents/agents.py +++ b/src/agentex/resources/agents/agents.py @@ -44,7 +44,7 @@ def with_raw_response(self) -> AgentsResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return AgentsResourceWithRawResponse(self) @@ -53,7 +53,7 @@ def with_streaming_response(self) -> AgentsResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return AgentsResourceWithStreamingResponse(self) @@ -218,7 +218,7 @@ def with_raw_response(self) -> AsyncAgentsResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return AsyncAgentsResourceWithRawResponse(self) @@ -227,7 +227,7 @@ def with_streaming_response(self) -> AsyncAgentsResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return AsyncAgentsResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/agents/name.py b/src/agentex/resources/agents/name.py index a386d7fd..8906f03e 100644 --- a/src/agentex/resources/agents/name.py +++ b/src/agentex/resources/agents/name.py @@ -31,7 +31,7 @@ def with_raw_response(self) -> NameResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return NameResourceWithRawResponse(self) @@ -40,7 +40,7 @@ def with_streaming_response(self) -> NameResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return NameResourceWithStreamingResponse(self) @@ -164,7 +164,7 @@ def with_raw_response(self) -> AsyncNameResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return AsyncNameResourceWithRawResponse(self) @@ -173,7 +173,7 @@ def with_streaming_response(self) -> AsyncNameResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return AsyncNameResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/echo.py b/src/agentex/resources/echo.py index d80adb34..5966357a 100644 --- a/src/agentex/resources/echo.py +++ b/src/agentex/resources/echo.py @@ -27,7 +27,7 @@ def with_raw_response(self) -> EchoResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return EchoResourceWithRawResponse(self) @@ -36,7 +36,7 @@ def with_streaming_response(self) -> EchoResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return EchoResourceWithStreamingResponse(self) @@ -80,7 +80,7 @@ def with_raw_response(self) -> AsyncEchoResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return AsyncEchoResourceWithRawResponse(self) @@ -89,7 +89,7 @@ def with_streaming_response(self) -> AsyncEchoResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return AsyncEchoResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/events.py b/src/agentex/resources/events.py index 652de518..79f6fa1b 100644 --- a/src/agentex/resources/events.py +++ b/src/agentex/resources/events.py @@ -31,7 +31,7 @@ def with_raw_response(self) -> EventsResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return EventsResourceWithRawResponse(self) @@ -40,7 +40,7 @@ def with_streaming_response(self) -> EventsResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return EventsResourceWithStreamingResponse(self) @@ -142,7 +142,7 @@ def with_raw_response(self) -> AsyncEventsResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return AsyncEventsResourceWithRawResponse(self) @@ -151,7 +151,7 @@ def with_streaming_response(self) -> AsyncEventsResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return AsyncEventsResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/messages/batch.py b/src/agentex/resources/messages/batch.py index 455683ea..478c2df5 100644 --- a/src/agentex/resources/messages/batch.py +++ b/src/agentex/resources/messages/batch.py @@ -31,7 +31,7 @@ def with_raw_response(self) -> BatchResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return BatchResourceWithRawResponse(self) @@ -40,7 +40,7 @@ def with_streaming_response(self) -> BatchResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return BatchResourceWithStreamingResponse(self) @@ -130,7 +130,7 @@ def with_raw_response(self) -> AsyncBatchResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return AsyncBatchResourceWithRawResponse(self) @@ -139,7 +139,7 @@ def with_streaming_response(self) -> AsyncBatchResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return AsyncBatchResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index fd15714b..7745cf76 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -44,7 +44,7 @@ def with_raw_response(self) -> MessagesResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return MessagesResourceWithRawResponse(self) @@ -53,7 +53,7 @@ def with_streaming_response(self) -> MessagesResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return MessagesResourceWithStreamingResponse(self) @@ -229,7 +229,7 @@ def with_raw_response(self) -> AsyncMessagesResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return AsyncMessagesResourceWithRawResponse(self) @@ -238,7 +238,7 @@ def with_streaming_response(self) -> AsyncMessagesResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return AsyncMessagesResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/spans.py b/src/agentex/resources/spans.py index 541c951c..00327697 100644 --- a/src/agentex/resources/spans.py +++ b/src/agentex/resources/spans.py @@ -32,7 +32,7 @@ def with_raw_response(self) -> SpansResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return SpansResourceWithRawResponse(self) @@ -41,7 +41,7 @@ def with_streaming_response(self) -> SpansResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return SpansResourceWithStreamingResponse(self) @@ -262,7 +262,7 @@ def with_raw_response(self) -> AsyncSpansResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return AsyncSpansResourceWithRawResponse(self) @@ -271,7 +271,7 @@ def with_streaming_response(self) -> AsyncSpansResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return AsyncSpansResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/states.py b/src/agentex/resources/states.py index 84a0a1de..6147890a 100644 --- a/src/agentex/resources/states.py +++ b/src/agentex/resources/states.py @@ -31,7 +31,7 @@ def with_raw_response(self) -> StatesResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return StatesResourceWithRawResponse(self) @@ -40,7 +40,7 @@ def with_streaming_response(self) -> StatesResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return StatesResourceWithStreamingResponse(self) @@ -249,7 +249,7 @@ def with_raw_response(self) -> AsyncStatesResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return AsyncStatesResourceWithRawResponse(self) @@ -258,7 +258,7 @@ def with_streaming_response(self) -> AsyncStatesResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return AsyncStatesResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/tasks/name.py b/src/agentex/resources/tasks/name.py index cec79c27..7cef42eb 100644 --- a/src/agentex/resources/tasks/name.py +++ b/src/agentex/resources/tasks/name.py @@ -27,7 +27,7 @@ def with_raw_response(self) -> NameResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return NameResourceWithRawResponse(self) @@ -36,7 +36,7 @@ def with_streaming_response(self) -> NameResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return NameResourceWithStreamingResponse(self) @@ -149,7 +149,7 @@ def with_raw_response(self) -> AsyncNameResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return AsyncNameResourceWithRawResponse(self) @@ -158,7 +158,7 @@ def with_streaming_response(self) -> AsyncNameResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return AsyncNameResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/tasks/tasks.py b/src/agentex/resources/tasks/tasks.py index b73374e4..ba8161ed 100644 --- a/src/agentex/resources/tasks/tasks.py +++ b/src/agentex/resources/tasks/tasks.py @@ -40,7 +40,7 @@ def with_raw_response(self) -> TasksResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return TasksResourceWithRawResponse(self) @@ -49,7 +49,7 @@ def with_streaming_response(self) -> TasksResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return TasksResourceWithStreamingResponse(self) @@ -185,7 +185,7 @@ def with_raw_response(self) -> AsyncTasksResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return AsyncTasksResourceWithRawResponse(self) @@ -194,7 +194,7 @@ def with_streaming_response(self) -> AsyncTasksResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return AsyncTasksResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/tracker.py b/src/agentex/resources/tracker.py index f6236903..1a74df21 100644 --- a/src/agentex/resources/tracker.py +++ b/src/agentex/resources/tracker.py @@ -31,7 +31,7 @@ def with_raw_response(self) -> TrackerResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return TrackerResourceWithRawResponse(self) @@ -40,7 +40,7 @@ def with_streaming_response(self) -> TrackerResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return TrackerResourceWithStreamingResponse(self) @@ -181,7 +181,7 @@ def with_raw_response(self) -> AsyncTrackerResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers """ return AsyncTrackerResourceWithRawResponse(self) @@ -190,7 +190,7 @@ def with_streaming_response(self) -> AsyncTrackerResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/stainless-sdks/agentex-sdk-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response """ return AsyncTrackerResourceWithStreamingResponse(self) From 75e775ac3b7718df39d3fb16664eb4026f361332 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 22 Jul 2025 01:15:19 +0000 Subject: [PATCH 0021/1108] codegen metadata --- .stats.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.stats.yml b/.stats.yml index fcb57dba..f89209bb 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 36 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-021b55c88964b7a5bfc9d692d32a52c6b0150445656d2407c4cb8e9dd1e5f100.yml openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 -config_hash: 7da7819f4e997d293e02d83e7fd0aca7 +config_hash: ea7ccb4f8ed1981b364cef82aa595243 From f0ee0117c58f2588d9d922aef3b793d33f6ecf2d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 22 Jul 2025 01:18:18 +0000 Subject: [PATCH 0022/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index c4762802..55f722d9 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.0.1-alpha.0" + ".": "0.0.1-alpha.1" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 30ed0424..2769d9ca 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex" -version = "0.0.1-alpha.0" +version = "0.0.1-alpha.1" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 0e0636b8..3b76e3fe 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.0.1-alpha.0" # x-release-please-version +__version__ = "0.0.1-alpha.1" # x-release-please-version From 463ab3cc6c3b700d3dc26024dfe6aede26aeed7b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 22 Jul 2025 01:32:41 +0000 Subject: [PATCH 0023/1108] feat(api): manual updates --- .stats.yml | 8 +- README.md | 48 +-- api.md | 68 ++-- src/agentex/__init__.py | 14 +- src/agentex/_client.py | 191 ++++------ src/agentex/resources/__init__.py | 14 - src/agentex/resources/{agents => }/agents.py | 332 ++++++++++++++--- src/agentex/resources/agents/__init__.py | 33 -- src/agentex/resources/agents/name.py | 350 ------------------ src/agentex/resources/echo.py | 162 -------- src/agentex/resources/messages/batch.py | 9 +- src/agentex/resources/messages/messages.py | 21 +- src/agentex/resources/{tasks => }/tasks.py | 286 ++++++++++++-- src/agentex/resources/tasks/__init__.py | 33 -- src/agentex/resources/tasks/name.py | 324 ---------------- src/agentex/types/__init__.py | 12 +- src/agentex/types/agent_rpc_by_name_params.py | 21 ++ src/agentex/types/agent_rpc_params.py | 54 +-- src/agentex/types/agent_rpc_params1.py | 21 ++ src/agentex/types/agent_rpc_response.py | 20 + src/agentex/types/agent_rpc_result.py | 90 +++++ src/agentex/types/agents/__init__.py | 5 - src/agentex/types/agents/name_rpc_params.py | 85 ----- src/agentex/types/data_delta.py | 14 + src/agentex/types/echo_send_params.py | 11 - src/agentex/types/event.py | 17 +- src/agentex/types/message_create_params.py | 19 +- src/agentex/types/message_update_params.py | 19 +- .../types/messages/batch_create_params.py | 16 +- .../types/messages/batch_update_params.py | 16 +- src/agentex/types/streaming_status.py | 7 - src/agentex/types/task_message.py | 37 +- src/agentex/types/task_message_content.py | 16 + .../types/task_message_content_param.py | 17 + src/agentex/types/task_message_delta.py | 16 + src/agentex/types/tasks/__init__.py | 3 - src/agentex/types/text_delta.py | 14 + src/agentex/types/tool_request_delta.py | 18 + src/agentex/types/tool_response_delta.py | 18 + tests/api_resources/agents/__init__.py | 1 - tests/api_resources/agents/test_name.py | 322 ---------------- tests/api_resources/tasks/__init__.py | 1 - tests/api_resources/tasks/test_name.py | 274 -------------- tests/api_resources/test_agents.py | 320 +++++++++++++++- tests/api_resources/test_client.py | 79 ---- tests/api_resources/test_echo.py | 91 ----- tests/api_resources/test_tasks.py | 250 +++++++++++++ tests/conftest.py | 8 +- tests/test_client.py | 253 ++++--------- 49 files changed, 1672 insertions(+), 2386 deletions(-) rename src/agentex/resources/{agents => }/agents.py (57%) delete mode 100644 src/agentex/resources/agents/__init__.py delete mode 100644 src/agentex/resources/agents/name.py delete mode 100644 src/agentex/resources/echo.py rename src/agentex/resources/{tasks => }/tasks.py (58%) delete mode 100644 src/agentex/resources/tasks/__init__.py delete mode 100644 src/agentex/resources/tasks/name.py create mode 100644 src/agentex/types/agent_rpc_by_name_params.py create mode 100644 src/agentex/types/agent_rpc_params1.py create mode 100644 src/agentex/types/agent_rpc_response.py create mode 100644 src/agentex/types/agent_rpc_result.py delete mode 100644 src/agentex/types/agents/__init__.py delete mode 100644 src/agentex/types/agents/name_rpc_params.py create mode 100644 src/agentex/types/data_delta.py delete mode 100644 src/agentex/types/echo_send_params.py delete mode 100644 src/agentex/types/streaming_status.py create mode 100644 src/agentex/types/task_message_content.py create mode 100644 src/agentex/types/task_message_content_param.py create mode 100644 src/agentex/types/task_message_delta.py delete mode 100644 src/agentex/types/tasks/__init__.py create mode 100644 src/agentex/types/text_delta.py create mode 100644 src/agentex/types/tool_request_delta.py create mode 100644 src/agentex/types/tool_response_delta.py delete mode 100644 tests/api_resources/agents/__init__.py delete mode 100644 tests/api_resources/agents/test_name.py delete mode 100644 tests/api_resources/tasks/__init__.py delete mode 100644 tests/api_resources/tasks/test_name.py delete mode 100644 tests/api_resources/test_client.py delete mode 100644 tests/api_resources/test_echo.py diff --git a/.stats.yml b/.stats.yml index f89209bb..2aac9130 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 36 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-021b55c88964b7a5bfc9d692d32a52c6b0150445656d2407c4cb8e9dd1e5f100.yml -openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 -config_hash: ea7ccb4f8ed1981b364cef82aa595243 +configured_endpoints: 34 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1d08fb2290b5310c91801d7575d356628d372fd5434e15d3b9cead48eadb893f.yml +openapi_spec_hash: 216a0edbf4e1a3cde23329d4f385faed +config_hash: 7661726e3cccf9f6349179841153601d diff --git a/README.md b/README.md index db9c7afa..2bdbb592 100644 --- a/README.md +++ b/README.md @@ -28,16 +28,17 @@ pip install git+ssh://git@github.com/scaleapi/agentex-python.git The full API of this library can be found in [api.md](api.md). ```python -import os from agentex import Agentex client = Agentex( - api_key=os.environ.get("AGENTEX_SDK_API_KEY"), # This is the default and can be omitted + # defaults to "production". + environment="development", ) -response = client.echo.send( - message="message", +agent = client.agents.retrieve( + "agent_id", ) +print(agent.id) ``` While you can provide an `api_key` keyword argument, @@ -50,19 +51,20 @@ so that your API Key is not stored in source control. Simply import `AsyncAgentex` instead of `Agentex` and use `await` with each API call: ```python -import os import asyncio from agentex import AsyncAgentex client = AsyncAgentex( - api_key=os.environ.get("AGENTEX_SDK_API_KEY"), # This is the default and can be omitted + # defaults to "production". + environment="development", ) async def main() -> None: - response = await client.echo.send( - message="message", + agent = await client.agents.retrieve( + "agent_id", ) + print(agent.id) asyncio.run(main()) @@ -91,12 +93,12 @@ from agentex import AsyncAgentex async def main() -> None: async with AsyncAgentex( - api_key="My API Key", http_client=DefaultAioHttpClient(), ) as client: - response = await client.echo.send( - message="message", + agent = await client.agents.retrieve( + "agent_id", ) + print(agent.id) asyncio.run(main()) @@ -127,8 +129,8 @@ from agentex import Agentex client = Agentex() try: - client.echo.send( - message="message", + client.agents.retrieve( + "agent_id", ) except agentex.APIConnectionError as e: print("The server could not be reached") @@ -172,8 +174,8 @@ client = Agentex( ) # Or, configure per-request: -client.with_options(max_retries=5).echo.send( - message="message", +client.with_options(max_retries=5).agents.retrieve( + "agent_id", ) ``` @@ -197,8 +199,8 @@ client = Agentex( ) # Override per-request: -client.with_options(timeout=5.0).echo.send( - message="message", +client.with_options(timeout=5.0).agents.retrieve( + "agent_id", ) ``` @@ -240,13 +242,13 @@ The "raw" Response object can be accessed by prefixing `.with_raw_response.` to from agentex import Agentex client = Agentex() -response = client.echo.with_raw_response.send( - message="message", +response = client.agents.with_raw_response.retrieve( + "agent_id", ) print(response.headers.get('X-My-Header')) -echo = response.parse() # get the object that `echo.send()` would have returned -print(echo) +agent = response.parse() # get the object that `agents.retrieve()` would have returned +print(agent.id) ``` These methods return an [`APIResponse`](https://github.com/scaleapi/agentex-python/tree/main/src/agentex/_response.py) object. @@ -260,8 +262,8 @@ The above interface eagerly reads the full response body when you make the reque To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods. ```python -with client.echo.with_streaming_response.send( - message="message", +with client.agents.with_streaming_response.retrieve( + "agent_id", ) as response: print(response.headers.get("X-My-Header")) diff --git a/api.md b/api.md index 45be6a64..8d4e6156 100644 --- a/api.md +++ b/api.md @@ -1,37 +1,35 @@ -# Agentex - -Methods: - -- client.get_root() -> object - -# Echo - -Methods: - -- client.echo.send(\*\*params) -> object - # Agents Types: ```python -from agentex.types import AcpType, Agent, AgentRpcRequest, AgentListResponse +from agentex.types import ( + AcpType, + Agent, + AgentRpcParams, + AgentRpcRequest, + AgentRpcResponse, + AgentRpcResult, + DataDelta, + TaskMessageContent, + TaskMessageDelta, + TaskMessageUpdate, + TextDelta, + ToolRequestDelta, + ToolResponseDelta, + AgentListResponse, +) ``` Methods: -- client.agents.retrieve(agent_id) -> Agent -- client.agents.list(\*\*params) -> AgentListResponse -- client.agents.delete(agent_id) -> Agent -- client.agents.rpc(agent_id, \*\*params) -> object - -## Name - -Methods: - -- client.agents.name.retrieve(agent_name) -> Agent -- client.agents.name.delete(agent_name) -> Agent -- client.agents.name.rpc(agent_name, \*\*params) -> object +- client.agents.retrieve(agent_id) -> Agent +- client.agents.list(\*\*params) -> AgentListResponse +- client.agents.delete(agent_id) -> Agent +- client.agents.delete_by_name(agent_name) -> Agent +- client.agents.retrieve_by_name(agent_name) -> Agent +- client.agents.rpc(agent_id, \*\*params) -> AgentRpcResponse +- client.agents.rpc_by_name(agent_name, \*\*params) -> AgentRpcResponse # Tasks @@ -43,18 +41,13 @@ from agentex.types import Task, TaskListResponse Methods: -- client.tasks.retrieve(task_id) -> Task -- client.tasks.list() -> TaskListResponse -- client.tasks.delete(task_id) -> Task -- client.tasks.stream_events(task_id) -> object - -## Name - -Methods: - -- client.tasks.name.retrieve(task_name) -> Task -- client.tasks.name.delete(task_name) -> Task -- client.tasks.name.stream_events(task_name) -> object +- client.tasks.retrieve(task_id) -> Task +- client.tasks.list() -> TaskListResponse +- client.tasks.delete(task_id) -> Task +- client.tasks.delete_by_name(task_name) -> Task +- client.tasks.retrieve_by_name(task_name) -> Task +- client.tasks.stream_events(task_id) -> object +- client.tasks.stream_events_by_name(task_name) -> object # Messages @@ -65,7 +58,6 @@ from agentex.types import ( DataContent, MessageAuthor, MessageStyle, - StreamingStatus, TaskMessage, TextContent, ToolRequestContent, diff --git a/src/agentex/__init__.py b/src/agentex/__init__.py index 891c638e..50fd7ec6 100644 --- a/src/agentex/__init__.py +++ b/src/agentex/__init__.py @@ -5,7 +5,18 @@ from . import types from ._types import NOT_GIVEN, Omit, NoneType, NotGiven, Transport, ProxiesTypes from ._utils import file_from_path -from ._client import Client, Stream, Agentex, Timeout, Transport, AsyncClient, AsyncStream, AsyncAgentex, RequestOptions +from ._client import ( + ENVIRONMENTS, + Client, + Stream, + Agentex, + Timeout, + Transport, + AsyncClient, + AsyncStream, + AsyncAgentex, + RequestOptions, +) from ._models import BaseModel from ._version import __title__, __version__ from ._response import APIResponse as APIResponse, AsyncAPIResponse as AsyncAPIResponse @@ -61,6 +72,7 @@ "AsyncStream", "Agentex", "AsyncAgentex", + "ENVIRONMENTS", "file_from_path", "BaseModel", "DEFAULT_TIMEOUT", diff --git a/src/agentex/_client.py b/src/agentex/_client.py index ee34e357..51ebb5e8 100644 --- a/src/agentex/_client.py +++ b/src/agentex/_client.py @@ -3,8 +3,8 @@ from __future__ import annotations import os -from typing import Any, Union, Mapping -from typing_extensions import Self, override +from typing import Any, Dict, Union, Mapping, cast +from typing_extensions import Self, Literal, override import httpx @@ -12,10 +12,7 @@ from ._qs import Querystring from ._types import ( NOT_GIVEN, - Body, Omit, - Query, - Headers, Timeout, NotGiven, Transport, @@ -24,30 +21,35 @@ ) from ._utils import is_given, get_async_library from ._version import __version__ -from ._response import ( - to_raw_response_wrapper, - to_streamed_response_wrapper, - async_to_raw_response_wrapper, - async_to_streamed_response_wrapper, -) -from .resources import echo, spans, events, states, tracker +from .resources import spans, tasks, agents, events, states, tracker from ._streaming import Stream as Stream, AsyncStream as AsyncStream from ._exceptions import APIStatusError from ._base_client import ( DEFAULT_MAX_RETRIES, SyncAPIClient, AsyncAPIClient, - make_request_options, ) -from .resources.tasks import tasks -from .resources.agents import agents from .resources.messages import messages -__all__ = ["Timeout", "Transport", "ProxiesTypes", "RequestOptions", "Agentex", "AsyncAgentex", "Client", "AsyncClient"] +__all__ = [ + "ENVIRONMENTS", + "Timeout", + "Transport", + "ProxiesTypes", + "RequestOptions", + "Agentex", + "AsyncAgentex", + "Client", + "AsyncClient", +] + +ENVIRONMENTS: Dict[str, str] = { + "production": "http://localhost:5003", + "development": "http://localhost:5003", +} class Agentex(SyncAPIClient): - echo: echo.EchoResource agents: agents.AgentsResource tasks: tasks.TasksResource messages: messages.MessagesResource @@ -61,11 +63,14 @@ class Agentex(SyncAPIClient): # client options api_key: str | None + _environment: Literal["production", "development"] | NotGiven + def __init__( self, *, api_key: str | None = None, - base_url: str | httpx.URL | None = None, + environment: Literal["production", "development"] | NotGiven = NOT_GIVEN, + base_url: str | httpx.URL | None | NotGiven = NOT_GIVEN, timeout: Union[float, Timeout, None, NotGiven] = NOT_GIVEN, max_retries: int = DEFAULT_MAX_RETRIES, default_headers: Mapping[str, str] | None = None, @@ -92,10 +97,31 @@ def __init__( api_key = os.environ.get("AGENTEX_SDK_API_KEY") self.api_key = api_key - if base_url is None: - base_url = os.environ.get("AGENTEX_BASE_URL") - if base_url is None: - base_url = f"https://api.example.com" + self._environment = environment + + base_url_env = os.environ.get("AGENTEX_BASE_URL") + if is_given(base_url) and base_url is not None: + # cast required because mypy doesn't understand the type narrowing + base_url = cast("str | httpx.URL", base_url) # pyright: ignore[reportUnnecessaryCast] + elif is_given(environment): + if base_url_env and base_url is not None: + raise ValueError( + "Ambiguous URL; The `AGENTEX_BASE_URL` env var and the `environment` argument are given. If you want to use the environment, you must pass base_url=None", + ) + + try: + base_url = ENVIRONMENTS[environment] + except KeyError as exc: + raise ValueError(f"Unknown environment: {environment}") from exc + elif base_url_env is not None: + base_url = base_url_env + else: + self._environment = environment = "production" + + try: + base_url = ENVIRONMENTS[environment] + except KeyError as exc: + raise ValueError(f"Unknown environment: {environment}") from exc super().__init__( version=__version__, @@ -108,7 +134,6 @@ def __init__( _strict_response_validation=_strict_response_validation, ) - self.echo = echo.EchoResource(self) self.agents = agents.AgentsResource(self) self.tasks = tasks.TasksResource(self) self.messages = messages.MessagesResource(self) @@ -141,21 +166,11 @@ def default_headers(self) -> dict[str, str | Omit]: **self._custom_headers, } - @override - def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None: - if self.api_key and headers.get("Authorization"): - return - if isinstance(custom_headers.get("Authorization"), Omit): - return - - raise TypeError( - '"Could not resolve authentication method. Expected the api_key to be set. Or for the `Authorization` headers to be explicitly omitted"' - ) - def copy( self, *, api_key: str | None = None, + environment: Literal["production", "development"] | None = None, base_url: str | httpx.URL | None = None, timeout: float | Timeout | None | NotGiven = NOT_GIVEN, http_client: httpx.Client | None = None, @@ -191,6 +206,7 @@ def copy( return self.__class__( api_key=api_key or self.api_key, base_url=base_url or self.base_url, + environment=environment or self._environment, timeout=self.timeout if isinstance(timeout, NotGiven) else timeout, http_client=http_client, max_retries=max_retries if is_given(max_retries) else self.max_retries, @@ -203,25 +219,6 @@ def copy( # client.with_options(timeout=10).foo.create(...) with_options = copy - def get_root( - self, - *, - # 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, - ) -> object: - """Root""" - return self.get( - "/", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=object, - ) - @override def _make_status_error( self, @@ -257,7 +254,6 @@ def _make_status_error( class AsyncAgentex(AsyncAPIClient): - echo: echo.AsyncEchoResource agents: agents.AsyncAgentsResource tasks: tasks.AsyncTasksResource messages: messages.AsyncMessagesResource @@ -271,11 +267,14 @@ class AsyncAgentex(AsyncAPIClient): # client options api_key: str | None + _environment: Literal["production", "development"] | NotGiven + def __init__( self, *, api_key: str | None = None, - base_url: str | httpx.URL | None = None, + environment: Literal["production", "development"] | NotGiven = NOT_GIVEN, + base_url: str | httpx.URL | None | NotGiven = NOT_GIVEN, timeout: Union[float, Timeout, None, NotGiven] = NOT_GIVEN, max_retries: int = DEFAULT_MAX_RETRIES, default_headers: Mapping[str, str] | None = None, @@ -302,10 +301,31 @@ def __init__( api_key = os.environ.get("AGENTEX_SDK_API_KEY") self.api_key = api_key - if base_url is None: - base_url = os.environ.get("AGENTEX_BASE_URL") - if base_url is None: - base_url = f"https://api.example.com" + self._environment = environment + + base_url_env = os.environ.get("AGENTEX_BASE_URL") + if is_given(base_url) and base_url is not None: + # cast required because mypy doesn't understand the type narrowing + base_url = cast("str | httpx.URL", base_url) # pyright: ignore[reportUnnecessaryCast] + elif is_given(environment): + if base_url_env and base_url is not None: + raise ValueError( + "Ambiguous URL; The `AGENTEX_BASE_URL` env var and the `environment` argument are given. If you want to use the environment, you must pass base_url=None", + ) + + try: + base_url = ENVIRONMENTS[environment] + except KeyError as exc: + raise ValueError(f"Unknown environment: {environment}") from exc + elif base_url_env is not None: + base_url = base_url_env + else: + self._environment = environment = "production" + + try: + base_url = ENVIRONMENTS[environment] + except KeyError as exc: + raise ValueError(f"Unknown environment: {environment}") from exc super().__init__( version=__version__, @@ -318,7 +338,6 @@ def __init__( _strict_response_validation=_strict_response_validation, ) - self.echo = echo.AsyncEchoResource(self) self.agents = agents.AsyncAgentsResource(self) self.tasks = tasks.AsyncTasksResource(self) self.messages = messages.AsyncMessagesResource(self) @@ -351,21 +370,11 @@ def default_headers(self) -> dict[str, str | Omit]: **self._custom_headers, } - @override - def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None: - if self.api_key and headers.get("Authorization"): - return - if isinstance(custom_headers.get("Authorization"), Omit): - return - - raise TypeError( - '"Could not resolve authentication method. Expected the api_key to be set. Or for the `Authorization` headers to be explicitly omitted"' - ) - def copy( self, *, api_key: str | None = None, + environment: Literal["production", "development"] | None = None, base_url: str | httpx.URL | None = None, timeout: float | Timeout | None | NotGiven = NOT_GIVEN, http_client: httpx.AsyncClient | None = None, @@ -401,6 +410,7 @@ def copy( return self.__class__( api_key=api_key or self.api_key, base_url=base_url or self.base_url, + environment=environment or self._environment, timeout=self.timeout if isinstance(timeout, NotGiven) else timeout, http_client=http_client, max_retries=max_retries if is_given(max_retries) else self.max_retries, @@ -413,25 +423,6 @@ def copy( # client.with_options(timeout=10).foo.create(...) with_options = copy - async def get_root( - self, - *, - # 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, - ) -> object: - """Root""" - return await self.get( - "/", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=object, - ) - @override def _make_status_error( self, @@ -468,7 +459,6 @@ def _make_status_error( class AgentexWithRawResponse: def __init__(self, client: Agentex) -> None: - self.echo = echo.EchoResourceWithRawResponse(client.echo) self.agents = agents.AgentsResourceWithRawResponse(client.agents) self.tasks = tasks.TasksResourceWithRawResponse(client.tasks) self.messages = messages.MessagesResourceWithRawResponse(client.messages) @@ -477,14 +467,9 @@ def __init__(self, client: Agentex) -> None: self.events = events.EventsResourceWithRawResponse(client.events) self.tracker = tracker.TrackerResourceWithRawResponse(client.tracker) - self.get_root = to_raw_response_wrapper( - client.get_root, - ) - class AsyncAgentexWithRawResponse: def __init__(self, client: AsyncAgentex) -> None: - self.echo = echo.AsyncEchoResourceWithRawResponse(client.echo) self.agents = agents.AsyncAgentsResourceWithRawResponse(client.agents) self.tasks = tasks.AsyncTasksResourceWithRawResponse(client.tasks) self.messages = messages.AsyncMessagesResourceWithRawResponse(client.messages) @@ -493,14 +478,9 @@ def __init__(self, client: AsyncAgentex) -> None: self.events = events.AsyncEventsResourceWithRawResponse(client.events) self.tracker = tracker.AsyncTrackerResourceWithRawResponse(client.tracker) - self.get_root = async_to_raw_response_wrapper( - client.get_root, - ) - class AgentexWithStreamedResponse: def __init__(self, client: Agentex) -> None: - self.echo = echo.EchoResourceWithStreamingResponse(client.echo) self.agents = agents.AgentsResourceWithStreamingResponse(client.agents) self.tasks = tasks.TasksResourceWithStreamingResponse(client.tasks) self.messages = messages.MessagesResourceWithStreamingResponse(client.messages) @@ -509,14 +489,9 @@ def __init__(self, client: Agentex) -> None: self.events = events.EventsResourceWithStreamingResponse(client.events) self.tracker = tracker.TrackerResourceWithStreamingResponse(client.tracker) - self.get_root = to_streamed_response_wrapper( - client.get_root, - ) - class AsyncAgentexWithStreamedResponse: def __init__(self, client: AsyncAgentex) -> None: - self.echo = echo.AsyncEchoResourceWithStreamingResponse(client.echo) self.agents = agents.AsyncAgentsResourceWithStreamingResponse(client.agents) self.tasks = tasks.AsyncTasksResourceWithStreamingResponse(client.tasks) self.messages = messages.AsyncMessagesResourceWithStreamingResponse(client.messages) @@ -525,10 +500,6 @@ def __init__(self, client: AsyncAgentex) -> None: self.events = events.AsyncEventsResourceWithStreamingResponse(client.events) self.tracker = tracker.AsyncTrackerResourceWithStreamingResponse(client.tracker) - self.get_root = async_to_streamed_response_wrapper( - client.get_root, - ) - Client = Agentex diff --git a/src/agentex/resources/__init__.py b/src/agentex/resources/__init__.py index d4758f92..cbf2ff6e 100644 --- a/src/agentex/resources/__init__.py +++ b/src/agentex/resources/__init__.py @@ -1,13 +1,5 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from .echo import ( - EchoResource, - AsyncEchoResource, - EchoResourceWithRawResponse, - AsyncEchoResourceWithRawResponse, - EchoResourceWithStreamingResponse, - AsyncEchoResourceWithStreamingResponse, -) from .spans import ( SpansResource, AsyncSpansResource, @@ -66,12 +58,6 @@ ) __all__ = [ - "EchoResource", - "AsyncEchoResource", - "EchoResourceWithRawResponse", - "AsyncEchoResourceWithRawResponse", - "EchoResourceWithStreamingResponse", - "AsyncEchoResourceWithStreamingResponse", "AgentsResource", "AsyncAgentsResource", "AgentsResourceWithRawResponse", diff --git a/src/agentex/resources/agents/agents.py b/src/agentex/resources/agents.py similarity index 57% rename from src/agentex/resources/agents/agents.py rename to src/agentex/resources/agents.py index 15b013d1..8b329be8 100644 --- a/src/agentex/resources/agents/agents.py +++ b/src/agentex/resources/agents.py @@ -7,37 +7,27 @@ import httpx -from .name import ( - NameResource, - AsyncNameResource, - NameResourceWithRawResponse, - AsyncNameResourceWithRawResponse, - NameResourceWithStreamingResponse, - AsyncNameResourceWithStreamingResponse, -) -from ...types import agent_rpc_params, agent_list_params -from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from ..._utils import maybe_transform, async_maybe_transform -from ..._compat import cached_property -from ..._resource import SyncAPIResource, AsyncAPIResource -from ..._response import ( +from ..types import AgentRpcParams, agent_rpc_params, agent_list_params, agent_rpc_by_name_params +from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._utils import maybe_transform, async_maybe_transform +from .._compat import cached_property +from .._resource import SyncAPIResource, AsyncAPIResource +from .._response import ( to_raw_response_wrapper, to_streamed_response_wrapper, async_to_raw_response_wrapper, async_to_streamed_response_wrapper, ) -from ...types.agent import Agent -from ..._base_client import make_request_options -from ...types.agent_list_response import AgentListResponse +from ..types.agent import Agent +from .._base_client import make_request_options +from ..types.agent_rpc_params import AgentRpcParams +from ..types.agent_rpc_response import AgentRpcResponse +from ..types.agent_list_response import AgentListResponse __all__ = ["AgentsResource", "AsyncAgentsResource"] class AgentsResource(SyncAPIResource): - @cached_property - def name(self) -> NameResource: - return NameResource(self._client) - @cached_property def with_raw_response(self) -> AgentsResourceWithRawResponse: """ @@ -160,12 +150,78 @@ def delete( cast_to=Agent, ) + def delete_by_name( + self, + agent_name: str, + *, + # 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, + ) -> Agent: + """ + Delete an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return self._delete( + f"/agents/name/{agent_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + def retrieve_by_name( + self, + agent_name: str, + *, + # 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, + ) -> Agent: + """ + Get an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return self._get( + f"/agents/name/{agent_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + def rpc( self, agent_id: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_rpc_params.Params, + params: AgentRpcParams, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -174,11 +230,13 @@ def rpc( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> object: + ) -> AgentRpcResponse: """ Handle JSON-RPC requests for an agent by its unique ID. Args: + params: The parameters for the agent RPC request + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -203,15 +261,59 @@ def rpc( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=object, + cast_to=AgentRpcResponse, ) + def rpc_by_name( + self, + agent_name: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: AgentRpcParams, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> AgentRpcResponse: + """ + Handle JSON-RPC requests for an agent by its unique name. + + Args: + params: The parameters for the agent RPC request -class AsyncAgentsResource(AsyncAPIResource): - @cached_property - def name(self) -> AsyncNameResource: - return AsyncNameResource(self._client) + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return self._post( + f"/agents/name/{agent_name}/rpc", + body=maybe_transform( + { + "method": method, + "params": params, + "id": id, + "jsonrpc": jsonrpc, + }, + agent_rpc_by_name_params.AgentRpcByNameParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AgentRpcResponse, + ) + + +class AsyncAgentsResource(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncAgentsResourceWithRawResponse: """ @@ -334,12 +436,78 @@ async def delete( cast_to=Agent, ) + async def delete_by_name( + self, + agent_name: str, + *, + # 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, + ) -> Agent: + """ + Delete an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return await self._delete( + f"/agents/name/{agent_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + async def retrieve_by_name( + self, + agent_name: str, + *, + # 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, + ) -> Agent: + """ + Get an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return await self._get( + f"/agents/name/{agent_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + async def rpc( self, agent_id: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_rpc_params.Params, + params: AgentRpcParams, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -348,11 +516,13 @@ async def rpc( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> object: + ) -> AgentRpcResponse: """ Handle JSON-RPC requests for an agent by its unique ID. Args: + params: The parameters for the agent RPC request + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -377,7 +547,55 @@ async def rpc( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=object, + cast_to=AgentRpcResponse, + ) + + async def rpc_by_name( + self, + agent_name: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: AgentRpcParams, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> AgentRpcResponse: + """ + Handle JSON-RPC requests for an agent by its unique name. + + Args: + params: The parameters for the agent RPC request + + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return await self._post( + f"/agents/name/{agent_name}/rpc", + body=await async_maybe_transform( + { + "method": method, + "params": params, + "id": id, + "jsonrpc": jsonrpc, + }, + agent_rpc_by_name_params.AgentRpcByNameParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AgentRpcResponse, ) @@ -394,13 +612,18 @@ def __init__(self, agents: AgentsResource) -> None: self.delete = to_raw_response_wrapper( agents.delete, ) + self.delete_by_name = to_raw_response_wrapper( + agents.delete_by_name, + ) + self.retrieve_by_name = to_raw_response_wrapper( + agents.retrieve_by_name, + ) self.rpc = to_raw_response_wrapper( agents.rpc, ) - - @cached_property - def name(self) -> NameResourceWithRawResponse: - return NameResourceWithRawResponse(self._agents.name) + self.rpc_by_name = to_raw_response_wrapper( + agents.rpc_by_name, + ) class AsyncAgentsResourceWithRawResponse: @@ -416,13 +639,18 @@ def __init__(self, agents: AsyncAgentsResource) -> None: self.delete = async_to_raw_response_wrapper( agents.delete, ) + self.delete_by_name = async_to_raw_response_wrapper( + agents.delete_by_name, + ) + self.retrieve_by_name = async_to_raw_response_wrapper( + agents.retrieve_by_name, + ) self.rpc = async_to_raw_response_wrapper( agents.rpc, ) - - @cached_property - def name(self) -> AsyncNameResourceWithRawResponse: - return AsyncNameResourceWithRawResponse(self._agents.name) + self.rpc_by_name = async_to_raw_response_wrapper( + agents.rpc_by_name, + ) class AgentsResourceWithStreamingResponse: @@ -438,13 +666,18 @@ def __init__(self, agents: AgentsResource) -> None: self.delete = to_streamed_response_wrapper( agents.delete, ) + self.delete_by_name = to_streamed_response_wrapper( + agents.delete_by_name, + ) + self.retrieve_by_name = to_streamed_response_wrapper( + agents.retrieve_by_name, + ) self.rpc = to_streamed_response_wrapper( agents.rpc, ) - - @cached_property - def name(self) -> NameResourceWithStreamingResponse: - return NameResourceWithStreamingResponse(self._agents.name) + self.rpc_by_name = to_streamed_response_wrapper( + agents.rpc_by_name, + ) class AsyncAgentsResourceWithStreamingResponse: @@ -460,10 +693,15 @@ def __init__(self, agents: AsyncAgentsResource) -> None: self.delete = async_to_streamed_response_wrapper( agents.delete, ) + self.delete_by_name = async_to_streamed_response_wrapper( + agents.delete_by_name, + ) + self.retrieve_by_name = async_to_streamed_response_wrapper( + agents.retrieve_by_name, + ) self.rpc = async_to_streamed_response_wrapper( agents.rpc, ) - - @cached_property - def name(self) -> AsyncNameResourceWithStreamingResponse: - return AsyncNameResourceWithStreamingResponse(self._agents.name) + self.rpc_by_name = async_to_streamed_response_wrapper( + agents.rpc_by_name, + ) diff --git a/src/agentex/resources/agents/__init__.py b/src/agentex/resources/agents/__init__.py deleted file mode 100644 index 374345e0..00000000 --- a/src/agentex/resources/agents/__init__.py +++ /dev/null @@ -1,33 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .name import ( - NameResource, - AsyncNameResource, - NameResourceWithRawResponse, - AsyncNameResourceWithRawResponse, - NameResourceWithStreamingResponse, - AsyncNameResourceWithStreamingResponse, -) -from .agents import ( - AgentsResource, - AsyncAgentsResource, - AgentsResourceWithRawResponse, - AsyncAgentsResourceWithRawResponse, - AgentsResourceWithStreamingResponse, - AsyncAgentsResourceWithStreamingResponse, -) - -__all__ = [ - "NameResource", - "AsyncNameResource", - "NameResourceWithRawResponse", - "AsyncNameResourceWithRawResponse", - "NameResourceWithStreamingResponse", - "AsyncNameResourceWithStreamingResponse", - "AgentsResource", - "AsyncAgentsResource", - "AgentsResourceWithRawResponse", - "AsyncAgentsResourceWithRawResponse", - "AgentsResourceWithStreamingResponse", - "AsyncAgentsResourceWithStreamingResponse", -] diff --git a/src/agentex/resources/agents/name.py b/src/agentex/resources/agents/name.py deleted file mode 100644 index 8906f03e..00000000 --- a/src/agentex/resources/agents/name.py +++ /dev/null @@ -1,350 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Union -from typing_extensions import Literal - -import httpx - -from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from ..._utils import maybe_transform, async_maybe_transform -from ..._compat import cached_property -from ..._resource import SyncAPIResource, AsyncAPIResource -from ..._response import ( - to_raw_response_wrapper, - to_streamed_response_wrapper, - async_to_raw_response_wrapper, - async_to_streamed_response_wrapper, -) -from ...types.agent import Agent -from ..._base_client import make_request_options -from ...types.agents import name_rpc_params - -__all__ = ["NameResource", "AsyncNameResource"] - - -class NameResource(SyncAPIResource): - @cached_property - def with_raw_response(self) -> NameResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers - """ - return NameResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> NameResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response - """ - return NameResourceWithStreamingResponse(self) - - def retrieve( - self, - agent_name: str, - *, - # 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, - ) -> Agent: - """ - Get an agent by its unique name. - - Args: - 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 - """ - if not agent_name: - raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") - return self._get( - f"/agents/name/{agent_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Agent, - ) - - def delete( - self, - agent_name: str, - *, - # 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, - ) -> Agent: - """ - Delete an agent by its unique name. - - Args: - 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 - """ - if not agent_name: - raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") - return self._delete( - f"/agents/name/{agent_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Agent, - ) - - def rpc( - self, - agent_name: str, - *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: name_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, - # 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, - ) -> object: - """ - Handle JSON-RPC requests for an agent by its unique name. - - Args: - 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 - """ - if not agent_name: - raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") - return self._post( - f"/agents/name/{agent_name}/rpc", - body=maybe_transform( - { - "method": method, - "params": params, - "id": id, - "jsonrpc": jsonrpc, - }, - name_rpc_params.NameRpcParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=object, - ) - - -class AsyncNameResource(AsyncAPIResource): - @cached_property - def with_raw_response(self) -> AsyncNameResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers - """ - return AsyncNameResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> AsyncNameResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response - """ - return AsyncNameResourceWithStreamingResponse(self) - - async def retrieve( - self, - agent_name: str, - *, - # 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, - ) -> Agent: - """ - Get an agent by its unique name. - - Args: - 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 - """ - if not agent_name: - raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") - return await self._get( - f"/agents/name/{agent_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Agent, - ) - - async def delete( - self, - agent_name: str, - *, - # 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, - ) -> Agent: - """ - Delete an agent by its unique name. - - Args: - 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 - """ - if not agent_name: - raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") - return await self._delete( - f"/agents/name/{agent_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Agent, - ) - - async def rpc( - self, - agent_name: str, - *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: name_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, - # 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, - ) -> object: - """ - Handle JSON-RPC requests for an agent by its unique name. - - Args: - 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 - """ - if not agent_name: - raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") - return await self._post( - f"/agents/name/{agent_name}/rpc", - body=await async_maybe_transform( - { - "method": method, - "params": params, - "id": id, - "jsonrpc": jsonrpc, - }, - name_rpc_params.NameRpcParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=object, - ) - - -class NameResourceWithRawResponse: - def __init__(self, name: NameResource) -> None: - self._name = name - - self.retrieve = to_raw_response_wrapper( - name.retrieve, - ) - self.delete = to_raw_response_wrapper( - name.delete, - ) - self.rpc = to_raw_response_wrapper( - name.rpc, - ) - - -class AsyncNameResourceWithRawResponse: - def __init__(self, name: AsyncNameResource) -> None: - self._name = name - - self.retrieve = async_to_raw_response_wrapper( - name.retrieve, - ) - self.delete = async_to_raw_response_wrapper( - name.delete, - ) - self.rpc = async_to_raw_response_wrapper( - name.rpc, - ) - - -class NameResourceWithStreamingResponse: - def __init__(self, name: NameResource) -> None: - self._name = name - - self.retrieve = to_streamed_response_wrapper( - name.retrieve, - ) - self.delete = to_streamed_response_wrapper( - name.delete, - ) - self.rpc = to_streamed_response_wrapper( - name.rpc, - ) - - -class AsyncNameResourceWithStreamingResponse: - def __init__(self, name: AsyncNameResource) -> None: - self._name = name - - self.retrieve = async_to_streamed_response_wrapper( - name.retrieve, - ) - self.delete = async_to_streamed_response_wrapper( - name.delete, - ) - self.rpc = async_to_streamed_response_wrapper( - name.rpc, - ) diff --git a/src/agentex/resources/echo.py b/src/agentex/resources/echo.py deleted file mode 100644 index 5966357a..00000000 --- a/src/agentex/resources/echo.py +++ /dev/null @@ -1,162 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -import httpx - -from ..types import echo_send_params -from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from .._utils import maybe_transform, async_maybe_transform -from .._compat import cached_property -from .._resource import SyncAPIResource, AsyncAPIResource -from .._response import ( - to_raw_response_wrapper, - to_streamed_response_wrapper, - async_to_raw_response_wrapper, - async_to_streamed_response_wrapper, -) -from .._base_client import make_request_options - -__all__ = ["EchoResource", "AsyncEchoResource"] - - -class EchoResource(SyncAPIResource): - @cached_property - def with_raw_response(self) -> EchoResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers - """ - return EchoResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> EchoResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response - """ - return EchoResourceWithStreamingResponse(self) - - def send( - self, - *, - message: str, - # 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, - ) -> object: - """ - Echo - - Args: - 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 - """ - return self._post( - "/echo", - body=maybe_transform({"message": message}, echo_send_params.EchoSendParams), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=object, - ) - - -class AsyncEchoResource(AsyncAPIResource): - @cached_property - def with_raw_response(self) -> AsyncEchoResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers - """ - return AsyncEchoResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> AsyncEchoResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response - """ - return AsyncEchoResourceWithStreamingResponse(self) - - async def send( - self, - *, - message: str, - # 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, - ) -> object: - """ - Echo - - Args: - 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 - """ - return await self._post( - "/echo", - body=await async_maybe_transform({"message": message}, echo_send_params.EchoSendParams), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=object, - ) - - -class EchoResourceWithRawResponse: - def __init__(self, echo: EchoResource) -> None: - self._echo = echo - - self.send = to_raw_response_wrapper( - echo.send, - ) - - -class AsyncEchoResourceWithRawResponse: - def __init__(self, echo: AsyncEchoResource) -> None: - self._echo = echo - - self.send = async_to_raw_response_wrapper( - echo.send, - ) - - -class EchoResourceWithStreamingResponse: - def __init__(self, echo: EchoResource) -> None: - self._echo = echo - - self.send = to_streamed_response_wrapper( - echo.send, - ) - - -class AsyncEchoResourceWithStreamingResponse: - def __init__(self, echo: AsyncEchoResource) -> None: - self._echo = echo - - self.send = async_to_streamed_response_wrapper( - echo.send, - ) diff --git a/src/agentex/resources/messages/batch.py b/src/agentex/resources/messages/batch.py index 478c2df5..58412663 100644 --- a/src/agentex/resources/messages/batch.py +++ b/src/agentex/resources/messages/batch.py @@ -18,6 +18,7 @@ ) from ..._base_client import make_request_options from ...types.messages import batch_create_params, batch_update_params +from ...types.task_message_content_param import TaskMessageContentParam from ...types.messages.batch_create_response import BatchCreateResponse from ...types.messages.batch_update_response import BatchUpdateResponse @@ -47,7 +48,7 @@ def with_streaming_response(self) -> BatchResourceWithStreamingResponse: def create( self, *, - contents: Iterable[batch_create_params.Content], + contents: Iterable[TaskMessageContentParam], task_id: str, # 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. @@ -87,7 +88,7 @@ def update( self, *, task_id: str, - updates: Dict[str, batch_update_params.Updates], + updates: Dict[str, TaskMessageContentParam], # 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, @@ -146,7 +147,7 @@ def with_streaming_response(self) -> AsyncBatchResourceWithStreamingResponse: async def create( self, *, - contents: Iterable[batch_create_params.Content], + contents: Iterable[TaskMessageContentParam], task_id: str, # 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. @@ -186,7 +187,7 @@ async def update( self, *, task_id: str, - updates: Dict[str, batch_update_params.Updates], + updates: Dict[str, TaskMessageContentParam], # 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, diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index 7745cf76..b7f78c94 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -3,6 +3,7 @@ from __future__ import annotations from typing import Optional +from typing_extensions import Literal import httpx @@ -14,7 +15,7 @@ BatchResourceWithStreamingResponse, AsyncBatchResourceWithStreamingResponse, ) -from ...types import StreamingStatus, message_list_params, message_create_params, message_update_params +from ...types import message_list_params, message_create_params, message_update_params from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property @@ -27,8 +28,8 @@ ) from ..._base_client import make_request_options from ...types.task_message import TaskMessage -from ...types.streaming_status import StreamingStatus from ...types.message_list_response import MessageListResponse +from ...types.task_message_content_param import TaskMessageContentParam __all__ = ["MessagesResource", "AsyncMessagesResource"] @@ -60,9 +61,9 @@ def with_streaming_response(self) -> MessagesResourceWithStreamingResponse: def create( self, *, - content: message_create_params.Content, + content: TaskMessageContentParam, task_id: str, - streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # 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, @@ -135,9 +136,9 @@ def update( self, message_id: str, *, - content: message_update_params.Content, + content: TaskMessageContentParam, task_id: str, - streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # 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, @@ -245,9 +246,9 @@ def with_streaming_response(self) -> AsyncMessagesResourceWithStreamingResponse: async def create( self, *, - content: message_create_params.Content, + content: TaskMessageContentParam, task_id: str, - streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # 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, @@ -320,9 +321,9 @@ async def update( self, message_id: str, *, - content: message_update_params.Content, + content: TaskMessageContentParam, task_id: str, - streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # 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, diff --git a/src/agentex/resources/tasks/tasks.py b/src/agentex/resources/tasks.py similarity index 58% rename from src/agentex/resources/tasks/tasks.py rename to src/agentex/resources/tasks.py index ba8161ed..936ee66c 100644 --- a/src/agentex/resources/tasks/tasks.py +++ b/src/agentex/resources/tasks.py @@ -4,36 +4,24 @@ import httpx -from .name import ( - NameResource, - AsyncNameResource, - NameResourceWithRawResponse, - AsyncNameResourceWithRawResponse, - NameResourceWithStreamingResponse, - AsyncNameResourceWithStreamingResponse, -) -from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from ..._compat import cached_property -from ..._resource import SyncAPIResource, AsyncAPIResource -from ..._response import ( +from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._compat import cached_property +from .._resource import SyncAPIResource, AsyncAPIResource +from .._response import ( to_raw_response_wrapper, to_streamed_response_wrapper, async_to_raw_response_wrapper, async_to_streamed_response_wrapper, ) -from ..._streaming import Stream, AsyncStream -from ...types.task import Task -from ..._base_client import make_request_options -from ...types.task_list_response import TaskListResponse +from .._streaming import Stream, AsyncStream +from ..types.task import Task +from .._base_client import make_request_options +from ..types.task_list_response import TaskListResponse __all__ = ["TasksResource", "AsyncTasksResource"] class TasksResource(SyncAPIResource): - @cached_property - def name(self) -> NameResource: - return NameResource(self._client) - @cached_property def with_raw_response(self) -> TasksResourceWithRawResponse: """ @@ -138,6 +126,72 @@ def delete( cast_to=Task, ) + def delete_by_name( + self, + task_name: str, + *, + # 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, + ) -> Task: + """ + Delete a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return self._delete( + f"/tasks/name/{task_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + + def retrieve_by_name( + self, + task_name: str, + *, + # 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, + ) -> Task: + """ + Get a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return self._get( + f"/tasks/name/{task_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + def stream_events( self, task_id: str, @@ -173,12 +227,43 @@ def stream_events( stream_cls=Stream[object], ) + def stream_events_by_name( + self, + task_name: str, + *, + # 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, + ) -> Stream[object]: + """ + Stream events for a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return self._get( + f"/tasks/name/{task_name}/stream", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + stream=True, + stream_cls=Stream[object], + ) -class AsyncTasksResource(AsyncAPIResource): - @cached_property - def name(self) -> AsyncNameResource: - return AsyncNameResource(self._client) +class AsyncTasksResource(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncTasksResourceWithRawResponse: """ @@ -283,6 +368,72 @@ async def delete( cast_to=Task, ) + async def delete_by_name( + self, + task_name: str, + *, + # 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, + ) -> Task: + """ + Delete a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return await self._delete( + f"/tasks/name/{task_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + + async def retrieve_by_name( + self, + task_name: str, + *, + # 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, + ) -> Task: + """ + Get a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return await self._get( + f"/tasks/name/{task_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + async def stream_events( self, task_id: str, @@ -318,6 +469,41 @@ async def stream_events( stream_cls=AsyncStream[object], ) + async def stream_events_by_name( + self, + task_name: str, + *, + # 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, + ) -> AsyncStream[object]: + """ + Stream events for a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return await self._get( + f"/tasks/name/{task_name}/stream", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + stream=True, + stream_cls=AsyncStream[object], + ) + class TasksResourceWithRawResponse: def __init__(self, tasks: TasksResource) -> None: @@ -332,13 +518,18 @@ def __init__(self, tasks: TasksResource) -> None: self.delete = to_raw_response_wrapper( tasks.delete, ) + self.delete_by_name = to_raw_response_wrapper( + tasks.delete_by_name, + ) + self.retrieve_by_name = to_raw_response_wrapper( + tasks.retrieve_by_name, + ) self.stream_events = to_raw_response_wrapper( tasks.stream_events, ) - - @cached_property - def name(self) -> NameResourceWithRawResponse: - return NameResourceWithRawResponse(self._tasks.name) + self.stream_events_by_name = to_raw_response_wrapper( + tasks.stream_events_by_name, + ) class AsyncTasksResourceWithRawResponse: @@ -354,13 +545,18 @@ def __init__(self, tasks: AsyncTasksResource) -> None: self.delete = async_to_raw_response_wrapper( tasks.delete, ) + self.delete_by_name = async_to_raw_response_wrapper( + tasks.delete_by_name, + ) + self.retrieve_by_name = async_to_raw_response_wrapper( + tasks.retrieve_by_name, + ) self.stream_events = async_to_raw_response_wrapper( tasks.stream_events, ) - - @cached_property - def name(self) -> AsyncNameResourceWithRawResponse: - return AsyncNameResourceWithRawResponse(self._tasks.name) + self.stream_events_by_name = async_to_raw_response_wrapper( + tasks.stream_events_by_name, + ) class TasksResourceWithStreamingResponse: @@ -376,13 +572,18 @@ def __init__(self, tasks: TasksResource) -> None: self.delete = to_streamed_response_wrapper( tasks.delete, ) + self.delete_by_name = to_streamed_response_wrapper( + tasks.delete_by_name, + ) + self.retrieve_by_name = to_streamed_response_wrapper( + tasks.retrieve_by_name, + ) self.stream_events = to_streamed_response_wrapper( tasks.stream_events, ) - - @cached_property - def name(self) -> NameResourceWithStreamingResponse: - return NameResourceWithStreamingResponse(self._tasks.name) + self.stream_events_by_name = to_streamed_response_wrapper( + tasks.stream_events_by_name, + ) class AsyncTasksResourceWithStreamingResponse: @@ -398,10 +599,15 @@ def __init__(self, tasks: AsyncTasksResource) -> None: self.delete = async_to_streamed_response_wrapper( tasks.delete, ) + self.delete_by_name = async_to_streamed_response_wrapper( + tasks.delete_by_name, + ) + self.retrieve_by_name = async_to_streamed_response_wrapper( + tasks.retrieve_by_name, + ) self.stream_events = async_to_streamed_response_wrapper( tasks.stream_events, ) - - @cached_property - def name(self) -> AsyncNameResourceWithStreamingResponse: - return AsyncNameResourceWithStreamingResponse(self._tasks.name) + self.stream_events_by_name = async_to_streamed_response_wrapper( + tasks.stream_events_by_name, + ) diff --git a/src/agentex/resources/tasks/__init__.py b/src/agentex/resources/tasks/__init__.py deleted file mode 100644 index 5a9c81b0..00000000 --- a/src/agentex/resources/tasks/__init__.py +++ /dev/null @@ -1,33 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .name import ( - NameResource, - AsyncNameResource, - NameResourceWithRawResponse, - AsyncNameResourceWithRawResponse, - NameResourceWithStreamingResponse, - AsyncNameResourceWithStreamingResponse, -) -from .tasks import ( - TasksResource, - AsyncTasksResource, - TasksResourceWithRawResponse, - AsyncTasksResourceWithRawResponse, - TasksResourceWithStreamingResponse, - AsyncTasksResourceWithStreamingResponse, -) - -__all__ = [ - "NameResource", - "AsyncNameResource", - "NameResourceWithRawResponse", - "AsyncNameResourceWithRawResponse", - "NameResourceWithStreamingResponse", - "AsyncNameResourceWithStreamingResponse", - "TasksResource", - "AsyncTasksResource", - "TasksResourceWithRawResponse", - "AsyncTasksResourceWithRawResponse", - "TasksResourceWithStreamingResponse", - "AsyncTasksResourceWithStreamingResponse", -] diff --git a/src/agentex/resources/tasks/name.py b/src/agentex/resources/tasks/name.py deleted file mode 100644 index 7cef42eb..00000000 --- a/src/agentex/resources/tasks/name.py +++ /dev/null @@ -1,324 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -import httpx - -from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from ..._compat import cached_property -from ..._resource import SyncAPIResource, AsyncAPIResource -from ..._response import ( - to_raw_response_wrapper, - to_streamed_response_wrapper, - async_to_raw_response_wrapper, - async_to_streamed_response_wrapper, -) -from ..._streaming import Stream, AsyncStream -from ...types.task import Task -from ..._base_client import make_request_options - -__all__ = ["NameResource", "AsyncNameResource"] - - -class NameResource(SyncAPIResource): - @cached_property - def with_raw_response(self) -> NameResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers - """ - return NameResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> NameResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response - """ - return NameResourceWithStreamingResponse(self) - - def retrieve( - self, - task_name: str, - *, - # 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, - ) -> Task: - """ - Get a task by its unique name. - - Args: - 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 - """ - if not task_name: - raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") - return self._get( - f"/tasks/name/{task_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Task, - ) - - def delete( - self, - task_name: str, - *, - # 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, - ) -> Task: - """ - Delete a task by its unique name. - - Args: - 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 - """ - if not task_name: - raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") - return self._delete( - f"/tasks/name/{task_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Task, - ) - - def stream_events( - self, - task_name: str, - *, - # 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, - ) -> Stream[object]: - """ - Stream events for a task by its unique name. - - Args: - 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 - """ - if not task_name: - raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") - return self._get( - f"/tasks/name/{task_name}/stream", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=object, - stream=True, - stream_cls=Stream[object], - ) - - -class AsyncNameResource(AsyncAPIResource): - @cached_property - def with_raw_response(self) -> AsyncNameResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers - """ - return AsyncNameResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> AsyncNameResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response - """ - return AsyncNameResourceWithStreamingResponse(self) - - async def retrieve( - self, - task_name: str, - *, - # 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, - ) -> Task: - """ - Get a task by its unique name. - - Args: - 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 - """ - if not task_name: - raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") - return await self._get( - f"/tasks/name/{task_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Task, - ) - - async def delete( - self, - task_name: str, - *, - # 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, - ) -> Task: - """ - Delete a task by its unique name. - - Args: - 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 - """ - if not task_name: - raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") - return await self._delete( - f"/tasks/name/{task_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Task, - ) - - async def stream_events( - self, - task_name: str, - *, - # 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, - ) -> AsyncStream[object]: - """ - Stream events for a task by its unique name. - - Args: - 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 - """ - if not task_name: - raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") - return await self._get( - f"/tasks/name/{task_name}/stream", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=object, - stream=True, - stream_cls=AsyncStream[object], - ) - - -class NameResourceWithRawResponse: - def __init__(self, name: NameResource) -> None: - self._name = name - - self.retrieve = to_raw_response_wrapper( - name.retrieve, - ) - self.delete = to_raw_response_wrapper( - name.delete, - ) - self.stream_events = to_raw_response_wrapper( - name.stream_events, - ) - - -class AsyncNameResourceWithRawResponse: - def __init__(self, name: AsyncNameResource) -> None: - self._name = name - - self.retrieve = async_to_raw_response_wrapper( - name.retrieve, - ) - self.delete = async_to_raw_response_wrapper( - name.delete, - ) - self.stream_events = async_to_raw_response_wrapper( - name.stream_events, - ) - - -class NameResourceWithStreamingResponse: - def __init__(self, name: NameResource) -> None: - self._name = name - - self.retrieve = to_streamed_response_wrapper( - name.retrieve, - ) - self.delete = to_streamed_response_wrapper( - name.delete, - ) - self.stream_events = to_streamed_response_wrapper( - name.stream_events, - ) - - -class AsyncNameResourceWithStreamingResponse: - def __init__(self, name: AsyncNameResource) -> None: - self._name = name - - self.retrieve = async_to_streamed_response_wrapper( - name.retrieve, - ) - self.delete = async_to_streamed_response_wrapper( - name.delete, - ) - self.stream_events = async_to_streamed_response_wrapper( - name.stream_events, - ) diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 17dc3aa2..26d1ecc8 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -8,32 +8,38 @@ from .event import Event as Event from .state import State as State from .acp_type import AcpType as AcpType +from .data_delta import DataDelta as DataDelta +from .text_delta import TextDelta as TextDelta from .data_content import DataContent as DataContent from .task_message import TaskMessage as TaskMessage from .text_content import TextContent as TextContent from .message_style import MessageStyle as MessageStyle from .message_author import MessageAuthor as MessageAuthor from .agent_rpc_params import AgentRpcParams as AgentRpcParams -from .echo_send_params import EchoSendParams as EchoSendParams +from .agent_rpc_result import AgentRpcResult as AgentRpcResult from .span_list_params import SpanListParams as SpanListParams -from .streaming_status import StreamingStatus as StreamingStatus from .agent_list_params import AgentListParams as AgentListParams from .event_list_params import EventListParams as EventListParams from .state_list_params import StateListParams as StateListParams +from .agent_rpc_response import AgentRpcResponse as AgentRpcResponse from .agent_task_tracker import AgentTaskTracker as AgentTaskTracker from .data_content_param import DataContentParam as DataContentParam from .span_create_params import SpanCreateParams as SpanCreateParams from .span_list_response import SpanListResponse as SpanListResponse from .span_update_params import SpanUpdateParams as SpanUpdateParams from .task_list_response import TaskListResponse as TaskListResponse +from .task_message_delta import TaskMessageDelta as TaskMessageDelta from .text_content_param import TextContentParam as TextContentParam +from .tool_request_delta import ToolRequestDelta as ToolRequestDelta from .agent_list_response import AgentListResponse as AgentListResponse from .event_list_response import EventListResponse as EventListResponse from .message_list_params import MessageListParams as MessageListParams from .state_create_params import StateCreateParams as StateCreateParams from .state_list_response import StateListResponse as StateListResponse from .state_update_params import StateUpdateParams as StateUpdateParams +from .tool_response_delta import ToolResponseDelta as ToolResponseDelta from .tracker_list_params import TrackerListParams as TrackerListParams +from .task_message_content import TaskMessageContent as TaskMessageContent from .tool_request_content import ToolRequestContent as ToolRequestContent from .message_create_params import MessageCreateParams as MessageCreateParams from .message_list_response import MessageListResponse as MessageListResponse @@ -41,5 +47,7 @@ from .tool_response_content import ToolResponseContent as ToolResponseContent from .tracker_list_response import TrackerListResponse as TrackerListResponse from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams +from .agent_rpc_by_name_params import AgentRpcByNameParams as AgentRpcByNameParams +from .task_message_content_param import TaskMessageContentParam as TaskMessageContentParam from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam diff --git a/src/agentex/types/agent_rpc_by_name_params.py b/src/agentex/types/agent_rpc_by_name_params.py new file mode 100644 index 00000000..5be189d7 --- /dev/null +++ b/src/agentex/types/agent_rpc_by_name_params.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union +from typing_extensions import Literal, Required, TypedDict + +from .agent_rpc_params import AgentRpcParams + +__all__ = ["AgentRpcByNameParams"] + + +class AgentRpcByNameParams(TypedDict, total=False): + method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] + + params: Required[AgentRpcParams] + """The parameters for the agent RPC request""" + + id: Union[int, str, None] + + jsonrpc: Literal["2.0"] diff --git a/src/agentex/types/agent_rpc_params.py b/src/agentex/types/agent_rpc_params.py index 2c79a7a9..5082b18c 100644 --- a/src/agentex/types/agent_rpc_params.py +++ b/src/agentex/types/agent_rpc_params.py @@ -3,36 +3,14 @@ from __future__ import annotations from typing import Dict, Union, Optional -from typing_extensions import Literal, Required, TypeAlias, TypedDict +from typing_extensions import Required, TypeAlias, TypedDict -from .data_content_param import DataContentParam -from .text_content_param import TextContentParam -from .tool_request_content_param import ToolRequestContentParam -from .tool_response_content_param import ToolResponseContentParam +from .task_message_content_param import TaskMessageContentParam -__all__ = [ - "AgentRpcParams", - "Params", - "ParamsCreateTaskRequest", - "ParamsCancelTaskRequest", - "ParamsSendMessageRequest", - "ParamsSendMessageRequestContent", - "ParamsSendEventRequest", - "ParamsSendEventRequestContent", -] +__all__ = ["AgentRpcParams", "CreateTaskRequest", "CancelTaskRequest", "SendMessageRequest", "SendEventRequest"] -class AgentRpcParams(TypedDict, total=False): - method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] - - params: Required[Params] - - id: Union[int, str, None] - - jsonrpc: Literal["2.0"] - - -class ParamsCreateTaskRequest(TypedDict, total=False): +class CreateTaskRequest(TypedDict, total=False): name: Optional[str] """The name of the task to create""" @@ -40,7 +18,7 @@ class ParamsCreateTaskRequest(TypedDict, total=False): """The parameters for the task""" -class ParamsCancelTaskRequest(TypedDict, total=False): +class CancelTaskRequest(TypedDict, total=False): task_id: Optional[str] """The ID of the task to cancel. Either this or task_name must be provided.""" @@ -48,13 +26,8 @@ class ParamsCancelTaskRequest(TypedDict, total=False): """The name of the task to cancel. Either this or task_id must be provided.""" -ParamsSendMessageRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendMessageRequest(TypedDict, total=False): - content: Required[ParamsSendMessageRequestContent] +class SendMessageRequest(TypedDict, total=False): + content: Required[TaskMessageContentParam] """The message that was sent to the agent""" stream: bool @@ -64,13 +37,8 @@ class ParamsSendMessageRequest(TypedDict, total=False): """The ID of the task that the message was sent to""" -ParamsSendEventRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendEventRequest(TypedDict, total=False): - content: Optional[ParamsSendEventRequestContent] +class SendEventRequest(TypedDict, total=False): + content: Optional[TaskMessageContentParam] """The content to send to the event""" task_id: Optional[str] @@ -80,6 +48,4 @@ class ParamsSendEventRequest(TypedDict, total=False): """The name of the task that the event was sent to""" -Params: TypeAlias = Union[ - ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest -] +AgentRpcParams: TypeAlias = Union[CreateTaskRequest, CancelTaskRequest, SendMessageRequest, SendEventRequest] diff --git a/src/agentex/types/agent_rpc_params1.py b/src/agentex/types/agent_rpc_params1.py new file mode 100644 index 00000000..3eae8b68 --- /dev/null +++ b/src/agentex/types/agent_rpc_params1.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union +from typing_extensions import Literal, Required, TypedDict + +from . import agent_rpc_params + +__all__ = ["AgentRpcParams"] + + +class AgentRpcParams(TypedDict, total=False): + method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] + + params: Required[agent_rpc_params.AgentRpcParams] + """The parameters for the agent RPC request""" + + id: Union[int, str, None] + + jsonrpc: Literal["2.0"] diff --git a/src/agentex/types/agent_rpc_response.py b/src/agentex/types/agent_rpc_response.py new file mode 100644 index 00000000..e9995e80 --- /dev/null +++ b/src/agentex/types/agent_rpc_response.py @@ -0,0 +1,20 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Union, Optional +from typing_extensions import Literal + +from .._models import BaseModel +from .agent_rpc_result import AgentRpcResult + +__all__ = ["AgentRpcResponse"] + + +class AgentRpcResponse(BaseModel): + result: Optional[AgentRpcResult] = None + """The result of the agent RPC request""" + + id: Union[int, str, None] = None + + error: Optional[object] = None + + jsonrpc: Optional[Literal["2.0"]] = None diff --git a/src/agentex/types/agent_rpc_result.py b/src/agentex/types/agent_rpc_result.py new file mode 100644 index 00000000..63e30a5d --- /dev/null +++ b/src/agentex/types/agent_rpc_result.py @@ -0,0 +1,90 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Union, Optional +from typing_extensions import Literal, TypeAlias + +from .task import Task +from .event import Event +from .._models import BaseModel +from .task_message import TaskMessage +from .task_message_delta import TaskMessageDelta +from .task_message_content import TaskMessageContent + +__all__ = [ + "AgentRpcResult", + "StreamTaskMessageStart", + "StreamTaskMessageDelta", + "StreamTaskMessageFull", + "StreamTaskMessageDone", +] + + +class StreamTaskMessageStart(BaseModel): + content: TaskMessageContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["start"]] = None + + +class StreamTaskMessageDelta(BaseModel): + delta: Optional[TaskMessageDelta] = None + """Delta for text updates""" + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["delta"]] = None + + +class StreamTaskMessageFull(BaseModel): + content: TaskMessageContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["full"]] = None + + +class StreamTaskMessageDone(BaseModel): + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["done"]] = None + + +AgentRpcResult: TypeAlias = Union[ + List[TaskMessage], + StreamTaskMessageStart, + StreamTaskMessageDelta, + StreamTaskMessageFull, + StreamTaskMessageDone, + Task, + Event, + None, +] diff --git a/src/agentex/types/agents/__init__.py b/src/agentex/types/agents/__init__.py deleted file mode 100644 index 6b2986a2..00000000 --- a/src/agentex/types/agents/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from .name_rpc_params import NameRpcParams as NameRpcParams diff --git a/src/agentex/types/agents/name_rpc_params.py b/src/agentex/types/agents/name_rpc_params.py deleted file mode 100644 index 6a68b0ba..00000000 --- a/src/agentex/types/agents/name_rpc_params.py +++ /dev/null @@ -1,85 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Dict, Union, Optional -from typing_extensions import Literal, Required, TypeAlias, TypedDict - -from ..data_content_param import DataContentParam -from ..text_content_param import TextContentParam -from ..tool_request_content_param import ToolRequestContentParam -from ..tool_response_content_param import ToolResponseContentParam - -__all__ = [ - "NameRpcParams", - "Params", - "ParamsCreateTaskRequest", - "ParamsCancelTaskRequest", - "ParamsSendMessageRequest", - "ParamsSendMessageRequestContent", - "ParamsSendEventRequest", - "ParamsSendEventRequestContent", -] - - -class NameRpcParams(TypedDict, total=False): - method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] - - params: Required[Params] - - id: Union[int, str, None] - - jsonrpc: Literal["2.0"] - - -class ParamsCreateTaskRequest(TypedDict, total=False): - name: Optional[str] - """The name of the task to create""" - - params: Optional[Dict[str, object]] - """The parameters for the task""" - - -class ParamsCancelTaskRequest(TypedDict, total=False): - task_id: Optional[str] - """The ID of the task to cancel. Either this or task_name must be provided.""" - - task_name: Optional[str] - """The name of the task to cancel. Either this or task_id must be provided.""" - - -ParamsSendMessageRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendMessageRequest(TypedDict, total=False): - content: Required[ParamsSendMessageRequestContent] - """The message that was sent to the agent""" - - stream: bool - """Whether to stream the response message back to the client""" - - task_id: Optional[str] - """The ID of the task that the message was sent to""" - - -ParamsSendEventRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendEventRequest(TypedDict, total=False): - content: Optional[ParamsSendEventRequestContent] - """The content to send to the event""" - - task_id: Optional[str] - """The ID of the task that the event was sent to""" - - task_name: Optional[str] - """The name of the task that the event was sent to""" - - -Params: TypeAlias = Union[ - ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest -] diff --git a/src/agentex/types/data_delta.py b/src/agentex/types/data_delta.py new file mode 100644 index 00000000..e30c12e7 --- /dev/null +++ b/src/agentex/types/data_delta.py @@ -0,0 +1,14 @@ +# 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__ = ["DataDelta"] + + +class DataDelta(BaseModel): + data_delta: Optional[str] = None + + type: Optional[Literal["data"]] = None diff --git a/src/agentex/types/echo_send_params.py b/src/agentex/types/echo_send_params.py deleted file mode 100644 index 3e237817..00000000 --- a/src/agentex/types/echo_send_params.py +++ /dev/null @@ -1,11 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing_extensions import Required, TypedDict - -__all__ = ["EchoSendParams"] - - -class EchoSendParams(TypedDict, total=False): - message: Required[str] diff --git a/src/agentex/types/event.py b/src/agentex/types/event.py index 3f1e5997..9a544cb6 100644 --- a/src/agentex/types/event.py +++ b/src/agentex/types/event.py @@ -1,21 +1,12 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Union, Optional +from typing import Optional from datetime import datetime -from typing_extensions import Annotated, TypeAlias -from .._utils import PropertyInfo from .._models import BaseModel -from .data_content import DataContent -from .text_content import TextContent -from .tool_request_content import ToolRequestContent -from .tool_response_content import ToolResponseContent +from .task_message_content import TaskMessageContent -__all__ = ["Event", "Content"] - -Content: TypeAlias = Annotated[ - Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent, None], PropertyInfo(discriminator="type") -] +__all__ = ["Event"] class Event(BaseModel): @@ -31,7 +22,7 @@ class Event(BaseModel): task_id: str """The UUID of the task that the event belongs to""" - content: Optional[Content] = None + content: Optional[TaskMessageContent] = None """The content of the event""" created_at: Optional[datetime] = None diff --git a/src/agentex/types/message_create_params.py b/src/agentex/types/message_create_params.py index 06ec3727..787715ec 100644 --- a/src/agentex/types/message_create_params.py +++ b/src/agentex/types/message_create_params.py @@ -2,24 +2,17 @@ from __future__ import annotations -from typing import Union, Optional -from typing_extensions import Required, TypeAlias, TypedDict +from typing import Optional +from typing_extensions import Literal, Required, TypedDict -from .streaming_status import StreamingStatus -from .data_content_param import DataContentParam -from .text_content_param import TextContentParam -from .tool_request_content_param import ToolRequestContentParam -from .tool_response_content_param import ToolResponseContentParam +from .task_message_content_param import TaskMessageContentParam -__all__ = ["MessageCreateParams", "Content"] +__all__ = ["MessageCreateParams"] class MessageCreateParams(TypedDict, total=False): - content: Required[Content] + content: Required[TaskMessageContentParam] task_id: Required[str] - streaming_status: Optional[StreamingStatus] - - -Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] diff --git a/src/agentex/types/message_update_params.py b/src/agentex/types/message_update_params.py index bc5305b8..ea3dbaf8 100644 --- a/src/agentex/types/message_update_params.py +++ b/src/agentex/types/message_update_params.py @@ -2,24 +2,17 @@ from __future__ import annotations -from typing import Union, Optional -from typing_extensions import Required, TypeAlias, TypedDict +from typing import Optional +from typing_extensions import Literal, Required, TypedDict -from .streaming_status import StreamingStatus -from .data_content_param import DataContentParam -from .text_content_param import TextContentParam -from .tool_request_content_param import ToolRequestContentParam -from .tool_response_content_param import ToolResponseContentParam +from .task_message_content_param import TaskMessageContentParam -__all__ = ["MessageUpdateParams", "Content"] +__all__ = ["MessageUpdateParams"] class MessageUpdateParams(TypedDict, total=False): - content: Required[Content] + content: Required[TaskMessageContentParam] task_id: Required[str] - streaming_status: Optional[StreamingStatus] - - -Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] diff --git a/src/agentex/types/messages/batch_create_params.py b/src/agentex/types/messages/batch_create_params.py index c09c69a9..0a0153ae 100644 --- a/src/agentex/types/messages/batch_create_params.py +++ b/src/agentex/types/messages/batch_create_params.py @@ -2,21 +2,15 @@ from __future__ import annotations -from typing import Union, Iterable -from typing_extensions import Required, TypeAlias, TypedDict +from typing import Iterable +from typing_extensions import Required, TypedDict -from ..data_content_param import DataContentParam -from ..text_content_param import TextContentParam -from ..tool_request_content_param import ToolRequestContentParam -from ..tool_response_content_param import ToolResponseContentParam +from ..task_message_content_param import TaskMessageContentParam -__all__ = ["BatchCreateParams", "Content"] +__all__ = ["BatchCreateParams"] class BatchCreateParams(TypedDict, total=False): - contents: Required[Iterable[Content]] + contents: Required[Iterable[TaskMessageContentParam]] task_id: Required[str] - - -Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex/types/messages/batch_update_params.py b/src/agentex/types/messages/batch_update_params.py index 68f24f8d..c25e46f6 100644 --- a/src/agentex/types/messages/batch_update_params.py +++ b/src/agentex/types/messages/batch_update_params.py @@ -2,21 +2,15 @@ from __future__ import annotations -from typing import Dict, Union -from typing_extensions import Required, TypeAlias, TypedDict +from typing import Dict +from typing_extensions import Required, TypedDict -from ..data_content_param import DataContentParam -from ..text_content_param import TextContentParam -from ..tool_request_content_param import ToolRequestContentParam -from ..tool_response_content_param import ToolResponseContentParam +from ..task_message_content_param import TaskMessageContentParam -__all__ = ["BatchUpdateParams", "Updates"] +__all__ = ["BatchUpdateParams"] class BatchUpdateParams(TypedDict, total=False): task_id: Required[str] - updates: Required[Dict[str, Updates]] - - -Updates: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] + updates: Required[Dict[str, TaskMessageContentParam]] diff --git a/src/agentex/types/streaming_status.py b/src/agentex/types/streaming_status.py deleted file mode 100644 index 196d7881..00000000 --- a/src/agentex/types/streaming_status.py +++ /dev/null @@ -1,7 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing_extensions import Literal, TypeAlias - -__all__ = ["StreamingStatus"] - -StreamingStatus: TypeAlias = Literal["IN_PROGRESS", "DONE"] diff --git a/src/agentex/types/task_message.py b/src/agentex/types/task_message.py index 686ade7d..b5938cc8 100644 --- a/src/agentex/types/task_message.py +++ b/src/agentex/types/task_message.py @@ -1,36 +1,33 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Union, Optional +from typing import Optional from datetime import datetime -from typing_extensions import Annotated, TypeAlias +from typing_extensions import Literal -from .._utils import PropertyInfo from .._models import BaseModel -from .data_content import DataContent -from .text_content import TextContent -from .streaming_status import StreamingStatus -from .tool_request_content import ToolRequestContent -from .tool_response_content import ToolResponseContent +from .task_message_content import TaskMessageContent -__all__ = ["TaskMessage", "Content"] - -Content: TypeAlias = Annotated[ - Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") -] +__all__ = ["TaskMessage"] class TaskMessage(BaseModel): - id: str - """The task message's unique id""" + content: TaskMessageContent + """The content of the message. - content: Content - - created_at: datetime - """The timestamp when the message was created""" + This content is not OpenAI compatible. These are messages that are meant to be + displayed to the user. + """ task_id: str + """ID of the task this message belongs to""" + + id: Optional[str] = None + """The task message's unique id""" + + created_at: Optional[datetime] = None + """The timestamp when the message was created""" - streaming_status: Optional[StreamingStatus] = None + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] = None updated_at: Optional[datetime] = None """The timestamp when the message was last updated""" diff --git a/src/agentex/types/task_message_content.py b/src/agentex/types/task_message_content.py new file mode 100644 index 00000000..126992b4 --- /dev/null +++ b/src/agentex/types/task_message_content.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Union +from typing_extensions import Annotated, TypeAlias + +from .._utils import PropertyInfo +from .data_content import DataContent +from .text_content import TextContent +from .tool_request_content import ToolRequestContent +from .tool_response_content import ToolResponseContent + +__all__ = ["TaskMessageContent"] + +TaskMessageContent: TypeAlias = Annotated[ + Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") +] diff --git a/src/agentex/types/task_message_content_param.py b/src/agentex/types/task_message_content_param.py new file mode 100644 index 00000000..6991c64e --- /dev/null +++ b/src/agentex/types/task_message_content_param.py @@ -0,0 +1,17 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union +from typing_extensions import TypeAlias + +from .data_content_param import DataContentParam +from .text_content_param import TextContentParam +from .tool_request_content_param import ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam + +__all__ = ["TaskMessageContentParam"] + +TaskMessageContentParam: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] diff --git a/src/agentex/types/task_message_delta.py b/src/agentex/types/task_message_delta.py new file mode 100644 index 00000000..5a477e5a --- /dev/null +++ b/src/agentex/types/task_message_delta.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Union +from typing_extensions import Annotated, TypeAlias + +from .._utils import PropertyInfo +from .data_delta import DataDelta +from .text_delta import TextDelta +from .tool_request_delta import ToolRequestDelta +from .tool_response_delta import ToolResponseDelta + +__all__ = ["TaskMessageDelta"] + +TaskMessageDelta: TypeAlias = Annotated[ + Union[TextDelta, DataDelta, ToolRequestDelta, ToolResponseDelta], PropertyInfo(discriminator="type") +] diff --git a/src/agentex/types/tasks/__init__.py b/src/agentex/types/tasks/__init__.py deleted file mode 100644 index f8ee8b14..00000000 --- a/src/agentex/types/tasks/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations diff --git a/src/agentex/types/text_delta.py b/src/agentex/types/text_delta.py new file mode 100644 index 00000000..29a60cfd --- /dev/null +++ b/src/agentex/types/text_delta.py @@ -0,0 +1,14 @@ +# 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__ = ["TextDelta"] + + +class TextDelta(BaseModel): + text_delta: Optional[str] = None + + type: Optional[Literal["text"]] = None diff --git a/src/agentex/types/tool_request_delta.py b/src/agentex/types/tool_request_delta.py new file mode 100644 index 00000000..7877dfdd --- /dev/null +++ b/src/agentex/types/tool_request_delta.py @@ -0,0 +1,18 @@ +# 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__ = ["ToolRequestDelta"] + + +class ToolRequestDelta(BaseModel): + name: str + + tool_call_id: str + + arguments_delta: Optional[str] = None + + type: Optional[Literal["tool_request"]] = None diff --git a/src/agentex/types/tool_response_delta.py b/src/agentex/types/tool_response_delta.py new file mode 100644 index 00000000..383770db --- /dev/null +++ b/src/agentex/types/tool_response_delta.py @@ -0,0 +1,18 @@ +# 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__ = ["ToolResponseDelta"] + + +class ToolResponseDelta(BaseModel): + name: str + + tool_call_id: str + + content_delta: Optional[str] = None + + type: Optional[Literal["tool_response"]] = None diff --git a/tests/api_resources/agents/__init__.py b/tests/api_resources/agents/__init__.py deleted file mode 100644 index fd8019a9..00000000 --- a/tests/api_resources/agents/__init__.py +++ /dev/null @@ -1 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/agents/test_name.py b/tests/api_resources/agents/test_name.py deleted file mode 100644 index a16fe447..00000000 --- a/tests/api_resources/agents/test_name.py +++ /dev/null @@ -1,322 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -import os -from typing import Any, cast - -import pytest - -from agentex import Agentex, AsyncAgentex -from tests.utils import assert_matches_type -from agentex.types import Agent - -base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") - - -class TestName: - parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - - @pytest.mark.skip() - @parametrize - def test_method_retrieve(self, client: Agentex) -> None: - name = client.agents.name.retrieve( - "agent_name", - ) - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_retrieve(self, client: Agentex) -> None: - response = client.agents.name.with_raw_response.retrieve( - "agent_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = response.parse() - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_retrieve(self, client: Agentex) -> None: - with client.agents.name.with_streaming_response.retrieve( - "agent_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = response.parse() - assert_matches_type(Agent, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - def test_path_params_retrieve(self, client: Agentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - client.agents.name.with_raw_response.retrieve( - "", - ) - - @pytest.mark.skip() - @parametrize - def test_method_delete(self, client: Agentex) -> None: - name = client.agents.name.delete( - "agent_name", - ) - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_delete(self, client: Agentex) -> None: - response = client.agents.name.with_raw_response.delete( - "agent_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = response.parse() - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_delete(self, client: Agentex) -> None: - with client.agents.name.with_streaming_response.delete( - "agent_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = response.parse() - assert_matches_type(Agent, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - def test_path_params_delete(self, client: Agentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - client.agents.name.with_raw_response.delete( - "", - ) - - @pytest.mark.skip() - @parametrize - def test_method_rpc(self, client: Agentex) -> None: - name = client.agents.name.rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_method_rpc_with_all_params(self, client: Agentex) -> None: - name = client.agents.name.rpc( - agent_name="agent_name", - method="event/send", - params={ - "name": "name", - "params": {"foo": "bar"}, - }, - id=0, - jsonrpc="2.0", - ) - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_rpc(self, client: Agentex) -> None: - response = client.agents.name.with_raw_response.rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = response.parse() - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_rpc(self, client: Agentex) -> None: - with client.agents.name.with_streaming_response.rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = response.parse() - assert_matches_type(object, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - def test_path_params_rpc(self, client: Agentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - client.agents.name.with_raw_response.rpc( - agent_name="", - method="event/send", - params={}, - ) - - -class TestAsyncName: - parametrize = pytest.mark.parametrize( - "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] - ) - - @pytest.mark.skip() - @parametrize - async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: - name = await async_client.agents.name.retrieve( - "agent_name", - ) - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: - response = await async_client.agents.name.with_raw_response.retrieve( - "agent_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = await response.parse() - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: - async with async_client.agents.name.with_streaming_response.retrieve( - "agent_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = await response.parse() - assert_matches_type(Agent, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - await async_client.agents.name.with_raw_response.retrieve( - "", - ) - - @pytest.mark.skip() - @parametrize - async def test_method_delete(self, async_client: AsyncAgentex) -> None: - name = await async_client.agents.name.delete( - "agent_name", - ) - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: - response = await async_client.agents.name.with_raw_response.delete( - "agent_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = await response.parse() - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> None: - async with async_client.agents.name.with_streaming_response.delete( - "agent_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = await response.parse() - assert_matches_type(Agent, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - await async_client.agents.name.with_raw_response.delete( - "", - ) - - @pytest.mark.skip() - @parametrize - async def test_method_rpc(self, async_client: AsyncAgentex) -> None: - name = await async_client.agents.name.rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_method_rpc_with_all_params(self, async_client: AsyncAgentex) -> None: - name = await async_client.agents.name.rpc( - agent_name="agent_name", - method="event/send", - params={ - "name": "name", - "params": {"foo": "bar"}, - }, - id=0, - jsonrpc="2.0", - ) - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_rpc(self, async_client: AsyncAgentex) -> None: - response = await async_client.agents.name.with_raw_response.rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = await response.parse() - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_rpc(self, async_client: AsyncAgentex) -> None: - async with async_client.agents.name.with_streaming_response.rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = await response.parse() - assert_matches_type(object, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - async def test_path_params_rpc(self, async_client: AsyncAgentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - await async_client.agents.name.with_raw_response.rpc( - agent_name="", - method="event/send", - params={}, - ) diff --git a/tests/api_resources/tasks/__init__.py b/tests/api_resources/tasks/__init__.py deleted file mode 100644 index fd8019a9..00000000 --- a/tests/api_resources/tasks/__init__.py +++ /dev/null @@ -1 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/tasks/test_name.py b/tests/api_resources/tasks/test_name.py deleted file mode 100644 index cb000659..00000000 --- a/tests/api_resources/tasks/test_name.py +++ /dev/null @@ -1,274 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -import os -from typing import Any, cast - -import pytest - -from agentex import Agentex, AsyncAgentex -from tests.utils import assert_matches_type -from agentex.types import Task - -base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") - - -class TestName: - parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - - @pytest.mark.skip() - @parametrize - def test_method_retrieve(self, client: Agentex) -> None: - name = client.tasks.name.retrieve( - "task_name", - ) - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_retrieve(self, client: Agentex) -> None: - response = client.tasks.name.with_raw_response.retrieve( - "task_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = response.parse() - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_retrieve(self, client: Agentex) -> None: - with client.tasks.name.with_streaming_response.retrieve( - "task_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = response.parse() - assert_matches_type(Task, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - def test_path_params_retrieve(self, client: Agentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): - client.tasks.name.with_raw_response.retrieve( - "", - ) - - @pytest.mark.skip() - @parametrize - def test_method_delete(self, client: Agentex) -> None: - name = client.tasks.name.delete( - "task_name", - ) - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_delete(self, client: Agentex) -> None: - response = client.tasks.name.with_raw_response.delete( - "task_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = response.parse() - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_delete(self, client: Agentex) -> None: - with client.tasks.name.with_streaming_response.delete( - "task_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = response.parse() - assert_matches_type(Task, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - def test_path_params_delete(self, client: Agentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): - client.tasks.name.with_raw_response.delete( - "", - ) - - @pytest.mark.skip() - @parametrize - def test_method_stream_events(self, client: Agentex) -> None: - name_stream = client.tasks.name.stream_events( - "task_name", - ) - name_stream.response.close() - - @pytest.mark.skip() - @parametrize - def test_raw_response_stream_events(self, client: Agentex) -> None: - response = client.tasks.name.with_raw_response.stream_events( - "task_name", - ) - - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - stream = response.parse() - stream.close() - - @pytest.mark.skip() - @parametrize - def test_streaming_response_stream_events(self, client: Agentex) -> None: - with client.tasks.name.with_streaming_response.stream_events( - "task_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - stream = response.parse() - stream.close() - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - def test_path_params_stream_events(self, client: Agentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): - client.tasks.name.with_raw_response.stream_events( - "", - ) - - -class TestAsyncName: - parametrize = pytest.mark.parametrize( - "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] - ) - - @pytest.mark.skip() - @parametrize - async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: - name = await async_client.tasks.name.retrieve( - "task_name", - ) - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: - response = await async_client.tasks.name.with_raw_response.retrieve( - "task_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = await response.parse() - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: - async with async_client.tasks.name.with_streaming_response.retrieve( - "task_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = await response.parse() - assert_matches_type(Task, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): - await async_client.tasks.name.with_raw_response.retrieve( - "", - ) - - @pytest.mark.skip() - @parametrize - async def test_method_delete(self, async_client: AsyncAgentex) -> None: - name = await async_client.tasks.name.delete( - "task_name", - ) - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: - response = await async_client.tasks.name.with_raw_response.delete( - "task_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = await response.parse() - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> None: - async with async_client.tasks.name.with_streaming_response.delete( - "task_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = await response.parse() - assert_matches_type(Task, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): - await async_client.tasks.name.with_raw_response.delete( - "", - ) - - @pytest.mark.skip() - @parametrize - async def test_method_stream_events(self, async_client: AsyncAgentex) -> None: - name_stream = await async_client.tasks.name.stream_events( - "task_name", - ) - await name_stream.response.aclose() - - @pytest.mark.skip() - @parametrize - async def test_raw_response_stream_events(self, async_client: AsyncAgentex) -> None: - response = await async_client.tasks.name.with_raw_response.stream_events( - "task_name", - ) - - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - stream = await response.parse() - await stream.close() - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_stream_events(self, async_client: AsyncAgentex) -> None: - async with async_client.tasks.name.with_streaming_response.stream_events( - "task_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - stream = await response.parse() - await stream.close() - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - async def test_path_params_stream_events(self, async_client: AsyncAgentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): - await async_client.tasks.name.with_raw_response.stream_events( - "", - ) diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index de1055f7..7cb79375 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -9,7 +9,11 @@ from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type -from agentex.types import Agent, AgentListResponse +from agentex.types import ( + Agent, + AgentRpcResponse, + AgentListResponse, +) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -137,6 +141,90 @@ def test_path_params_delete(self, client: Agentex) -> None: "", ) + @pytest.mark.skip() + @parametrize + def test_method_delete_by_name(self, client: Agentex) -> None: + agent = client.agents.delete_by_name( + "agent_name", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_delete_by_name(self, client: Agentex) -> None: + response = client.agents.with_raw_response.delete_by_name( + "agent_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_delete_by_name(self, client: Agentex) -> None: + with client.agents.with_streaming_response.delete_by_name( + "agent_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_delete_by_name(self, client: Agentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + client.agents.with_raw_response.delete_by_name( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_retrieve_by_name(self, client: Agentex) -> None: + agent = client.agents.retrieve_by_name( + "agent_name", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_retrieve_by_name(self, client: Agentex) -> None: + response = client.agents.with_raw_response.retrieve_by_name( + "agent_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_retrieve_by_name(self, client: Agentex) -> None: + with client.agents.with_streaming_response.retrieve_by_name( + "agent_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_retrieve_by_name(self, client: Agentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + client.agents.with_raw_response.retrieve_by_name( + "", + ) + @pytest.mark.skip() @parametrize def test_method_rpc(self, client: Agentex) -> None: @@ -145,7 +233,7 @@ def test_method_rpc(self, client: Agentex) -> None: method="event/send", params={}, ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -160,7 +248,7 @@ def test_method_rpc_with_all_params(self, client: Agentex) -> None: id=0, jsonrpc="2.0", ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -174,7 +262,7 @@ def test_raw_response_rpc(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -188,7 +276,7 @@ def test_streaming_response_rpc(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -202,6 +290,71 @@ def test_path_params_rpc(self, client: Agentex) -> None: params={}, ) + @pytest.mark.skip() + @parametrize + def test_method_rpc_by_name(self, client: Agentex) -> None: + agent = client.agents.rpc_by_name( + agent_name="agent_name", + method="event/send", + params={}, + ) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_rpc_by_name_with_all_params(self, client: Agentex) -> None: + agent = client.agents.rpc_by_name( + agent_name="agent_name", + method="event/send", + params={ + "name": "name", + "params": {"foo": "bar"}, + }, + id=0, + jsonrpc="2.0", + ) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_rpc_by_name(self, client: Agentex) -> None: + response = client.agents.with_raw_response.rpc_by_name( + agent_name="agent_name", + method="event/send", + params={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = response.parse() + assert_matches_type(AgentRpcResponse, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_rpc_by_name(self, client: Agentex) -> None: + with client.agents.with_streaming_response.rpc_by_name( + agent_name="agent_name", + method="event/send", + params={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = response.parse() + assert_matches_type(AgentRpcResponse, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_rpc_by_name(self, client: Agentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + client.agents.with_raw_response.rpc_by_name( + agent_name="", + method="event/send", + params={}, + ) + class TestAsyncAgents: parametrize = pytest.mark.parametrize( @@ -328,6 +481,90 @@ async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: "", ) + @pytest.mark.skip() + @parametrize + async def test_method_delete_by_name(self, async_client: AsyncAgentex) -> None: + agent = await async_client.agents.delete_by_name( + "agent_name", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_delete_by_name(self, async_client: AsyncAgentex) -> None: + response = await async_client.agents.with_raw_response.delete_by_name( + "agent_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = await response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_delete_by_name(self, async_client: AsyncAgentex) -> None: + async with async_client.agents.with_streaming_response.delete_by_name( + "agent_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = await response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_delete_by_name(self, async_client: AsyncAgentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + await async_client.agents.with_raw_response.delete_by_name( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_retrieve_by_name(self, async_client: AsyncAgentex) -> None: + agent = await async_client.agents.retrieve_by_name( + "agent_name", + ) + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_retrieve_by_name(self, async_client: AsyncAgentex) -> None: + response = await async_client.agents.with_raw_response.retrieve_by_name( + "agent_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = await response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_retrieve_by_name(self, async_client: AsyncAgentex) -> None: + async with async_client.agents.with_streaming_response.retrieve_by_name( + "agent_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = await response.parse() + assert_matches_type(Agent, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_retrieve_by_name(self, async_client: AsyncAgentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + await async_client.agents.with_raw_response.retrieve_by_name( + "", + ) + @pytest.mark.skip() @parametrize async def test_method_rpc(self, async_client: AsyncAgentex) -> None: @@ -336,7 +573,7 @@ async def test_method_rpc(self, async_client: AsyncAgentex) -> None: method="event/send", params={}, ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -351,7 +588,7 @@ async def test_method_rpc_with_all_params(self, async_client: AsyncAgentex) -> N id=0, jsonrpc="2.0", ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -365,7 +602,7 @@ async def test_raw_response_rpc(self, async_client: AsyncAgentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -379,7 +616,7 @@ async def test_streaming_response_rpc(self, async_client: AsyncAgentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -392,3 +629,68 @@ async def test_path_params_rpc(self, async_client: AsyncAgentex) -> None: method="event/send", params={}, ) + + @pytest.mark.skip() + @parametrize + async def test_method_rpc_by_name(self, async_client: AsyncAgentex) -> None: + agent = await async_client.agents.rpc_by_name( + agent_name="agent_name", + method="event/send", + params={}, + ) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_rpc_by_name_with_all_params(self, async_client: AsyncAgentex) -> None: + agent = await async_client.agents.rpc_by_name( + agent_name="agent_name", + method="event/send", + params={ + "name": "name", + "params": {"foo": "bar"}, + }, + id=0, + jsonrpc="2.0", + ) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_rpc_by_name(self, async_client: AsyncAgentex) -> None: + response = await async_client.agents.with_raw_response.rpc_by_name( + agent_name="agent_name", + method="event/send", + params={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = await response.parse() + assert_matches_type(AgentRpcResponse, agent, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_rpc_by_name(self, async_client: AsyncAgentex) -> None: + async with async_client.agents.with_streaming_response.rpc_by_name( + agent_name="agent_name", + method="event/send", + params={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = await response.parse() + assert_matches_type(AgentRpcResponse, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_rpc_by_name(self, async_client: AsyncAgentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + await async_client.agents.with_raw_response.rpc_by_name( + agent_name="", + method="event/send", + params={}, + ) diff --git a/tests/api_resources/test_client.py b/tests/api_resources/test_client.py deleted file mode 100644 index 82802d71..00000000 --- a/tests/api_resources/test_client.py +++ /dev/null @@ -1,79 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -import os -from typing import Any, cast - -import pytest - -from agentex import Agentex, AsyncAgentex -from tests.utils import assert_matches_type - -base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") - - -class TestClient: - parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - - @pytest.mark.skip() - @parametrize - def test_method_get_root(self, client: Agentex) -> None: - client_ = client.get_root() - assert_matches_type(object, client_, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_get_root(self, client: Agentex) -> None: - response = client.with_raw_response.get_root() - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - client_ = response.parse() - assert_matches_type(object, client_, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_get_root(self, client: Agentex) -> None: - with client.with_streaming_response.get_root() as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - client_ = response.parse() - assert_matches_type(object, client_, path=["response"]) - - assert cast(Any, response.is_closed) is True - - -class TestAsyncClient: - parametrize = pytest.mark.parametrize( - "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] - ) - - @pytest.mark.skip() - @parametrize - async def test_method_get_root(self, async_client: AsyncAgentex) -> None: - client = await async_client.get_root() - assert_matches_type(object, client, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_get_root(self, async_client: AsyncAgentex) -> None: - response = await async_client.with_raw_response.get_root() - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - client = await response.parse() - assert_matches_type(object, client, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_get_root(self, async_client: AsyncAgentex) -> None: - async with async_client.with_streaming_response.get_root() as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - client = await response.parse() - assert_matches_type(object, client, path=["response"]) - - assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_echo.py b/tests/api_resources/test_echo.py deleted file mode 100644 index 1a40d73f..00000000 --- a/tests/api_resources/test_echo.py +++ /dev/null @@ -1,91 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -import os -from typing import Any, cast - -import pytest - -from agentex import Agentex, AsyncAgentex -from tests.utils import assert_matches_type - -base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") - - -class TestEcho: - parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - - @pytest.mark.skip() - @parametrize - def test_method_send(self, client: Agentex) -> None: - echo = client.echo.send( - message="message", - ) - assert_matches_type(object, echo, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_send(self, client: Agentex) -> None: - response = client.echo.with_raw_response.send( - message="message", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - echo = response.parse() - assert_matches_type(object, echo, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_send(self, client: Agentex) -> None: - with client.echo.with_streaming_response.send( - message="message", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - echo = response.parse() - assert_matches_type(object, echo, path=["response"]) - - assert cast(Any, response.is_closed) is True - - -class TestAsyncEcho: - parametrize = pytest.mark.parametrize( - "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] - ) - - @pytest.mark.skip() - @parametrize - async def test_method_send(self, async_client: AsyncAgentex) -> None: - echo = await async_client.echo.send( - message="message", - ) - assert_matches_type(object, echo, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_send(self, async_client: AsyncAgentex) -> None: - response = await async_client.echo.with_raw_response.send( - message="message", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - echo = await response.parse() - assert_matches_type(object, echo, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_send(self, async_client: AsyncAgentex) -> None: - async with async_client.echo.with_streaming_response.send( - message="message", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - echo = await response.parse() - assert_matches_type(object, echo, path=["response"]) - - assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_tasks.py b/tests/api_resources/test_tasks.py index 060f051c..0c9af1b4 100644 --- a/tests/api_resources/test_tasks.py +++ b/tests/api_resources/test_tasks.py @@ -129,6 +129,90 @@ def test_path_params_delete(self, client: Agentex) -> None: "", ) + @pytest.mark.skip() + @parametrize + def test_method_delete_by_name(self, client: Agentex) -> None: + task = client.tasks.delete_by_name( + "task_name", + ) + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_delete_by_name(self, client: Agentex) -> None: + response = client.tasks.with_raw_response.delete_by_name( + "task_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + task = response.parse() + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_delete_by_name(self, client: Agentex) -> None: + with client.tasks.with_streaming_response.delete_by_name( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + task = response.parse() + assert_matches_type(Task, task, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_delete_by_name(self, client: Agentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + client.tasks.with_raw_response.delete_by_name( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_retrieve_by_name(self, client: Agentex) -> None: + task = client.tasks.retrieve_by_name( + "task_name", + ) + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_retrieve_by_name(self, client: Agentex) -> None: + response = client.tasks.with_raw_response.retrieve_by_name( + "task_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + task = response.parse() + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_retrieve_by_name(self, client: Agentex) -> None: + with client.tasks.with_streaming_response.retrieve_by_name( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + task = response.parse() + assert_matches_type(Task, task, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_retrieve_by_name(self, client: Agentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + client.tasks.with_raw_response.retrieve_by_name( + "", + ) + @pytest.mark.skip() @parametrize def test_method_stream_events(self, client: Agentex) -> None: @@ -170,6 +254,47 @@ def test_path_params_stream_events(self, client: Agentex) -> None: "", ) + @pytest.mark.skip() + @parametrize + def test_method_stream_events_by_name(self, client: Agentex) -> None: + task_stream = client.tasks.stream_events_by_name( + "task_name", + ) + task_stream.response.close() + + @pytest.mark.skip() + @parametrize + def test_raw_response_stream_events_by_name(self, client: Agentex) -> None: + response = client.tasks.with_raw_response.stream_events_by_name( + "task_name", + ) + + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + stream = response.parse() + stream.close() + + @pytest.mark.skip() + @parametrize + def test_streaming_response_stream_events_by_name(self, client: Agentex) -> None: + with client.tasks.with_streaming_response.stream_events_by_name( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + stream = response.parse() + stream.close() + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_stream_events_by_name(self, client: Agentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + client.tasks.with_raw_response.stream_events_by_name( + "", + ) + class TestAsyncTasks: parametrize = pytest.mark.parametrize( @@ -288,6 +413,90 @@ async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: "", ) + @pytest.mark.skip() + @parametrize + async def test_method_delete_by_name(self, async_client: AsyncAgentex) -> None: + task = await async_client.tasks.delete_by_name( + "task_name", + ) + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_delete_by_name(self, async_client: AsyncAgentex) -> None: + response = await async_client.tasks.with_raw_response.delete_by_name( + "task_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + task = await response.parse() + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_delete_by_name(self, async_client: AsyncAgentex) -> None: + async with async_client.tasks.with_streaming_response.delete_by_name( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + task = await response.parse() + assert_matches_type(Task, task, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_delete_by_name(self, async_client: AsyncAgentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + await async_client.tasks.with_raw_response.delete_by_name( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_retrieve_by_name(self, async_client: AsyncAgentex) -> None: + task = await async_client.tasks.retrieve_by_name( + "task_name", + ) + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_retrieve_by_name(self, async_client: AsyncAgentex) -> None: + response = await async_client.tasks.with_raw_response.retrieve_by_name( + "task_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + task = await response.parse() + assert_matches_type(Task, task, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_retrieve_by_name(self, async_client: AsyncAgentex) -> None: + async with async_client.tasks.with_streaming_response.retrieve_by_name( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + task = await response.parse() + assert_matches_type(Task, task, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_retrieve_by_name(self, async_client: AsyncAgentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + await async_client.tasks.with_raw_response.retrieve_by_name( + "", + ) + @pytest.mark.skip() @parametrize async def test_method_stream_events(self, async_client: AsyncAgentex) -> None: @@ -328,3 +537,44 @@ async def test_path_params_stream_events(self, async_client: AsyncAgentex) -> No await async_client.tasks.with_raw_response.stream_events( "", ) + + @pytest.mark.skip() + @parametrize + async def test_method_stream_events_by_name(self, async_client: AsyncAgentex) -> None: + task_stream = await async_client.tasks.stream_events_by_name( + "task_name", + ) + await task_stream.response.aclose() + + @pytest.mark.skip() + @parametrize + async def test_raw_response_stream_events_by_name(self, async_client: AsyncAgentex) -> None: + response = await async_client.tasks.with_raw_response.stream_events_by_name( + "task_name", + ) + + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + stream = await response.parse() + await stream.close() + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_stream_events_by_name(self, async_client: AsyncAgentex) -> None: + async with async_client.tasks.with_streaming_response.stream_events_by_name( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + stream = await response.parse() + await stream.close() + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_stream_events_by_name(self, async_client: AsyncAgentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + await async_client.tasks.with_raw_response.stream_events_by_name( + "", + ) diff --git a/tests/conftest.py b/tests/conftest.py index d08e65cf..b6e6697e 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -45,8 +45,6 @@ def pytest_collection_modifyitems(items: list[pytest.Function]) -> None: base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") -api_key = "My API Key" - @pytest.fixture(scope="session") def client(request: FixtureRequest) -> Iterator[Agentex]: @@ -54,7 +52,7 @@ def client(request: FixtureRequest) -> Iterator[Agentex]: if not isinstance(strict, bool): raise TypeError(f"Unexpected fixture parameter type {type(strict)}, expected {bool}") - with Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=strict) as client: + with Agentex(base_url=base_url, _strict_response_validation=strict) as client: yield client @@ -78,7 +76,5 @@ async def async_client(request: FixtureRequest) -> AsyncIterator[AsyncAgentex]: else: raise TypeError(f"Unexpected fixture parameter type {type(param)}, expected bool or dict") - async with AsyncAgentex( - base_url=base_url, api_key=api_key, _strict_response_validation=strict, http_client=http_client - ) as client: + async with AsyncAgentex(base_url=base_url, _strict_response_validation=strict, http_client=http_client) as client: yield client diff --git a/tests/test_client.py b/tests/test_client.py index bb8ce7ed..2fe22ed9 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -37,7 +37,6 @@ from .utils import update_env base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") -api_key = "My API Key" def _get_params(client: BaseClient[Any, Any]) -> dict[str, str]: @@ -59,7 +58,7 @@ def _get_open_connections(client: Agentex | AsyncAgentex) -> int: class TestAgentex: - client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = Agentex(base_url=base_url, _strict_response_validation=True) @pytest.mark.respx(base_url=base_url) def test_raw_response(self, respx_mock: MockRouter) -> None: @@ -85,10 +84,6 @@ def test_copy(self) -> None: copied = self.client.copy() assert id(copied) != id(self.client) - copied = self.client.copy(api_key="another My API Key") - assert copied.api_key == "another My API Key" - assert self.client.api_key == "My API Key" - def test_copy_default_options(self) -> None: # options that have a default are overridden correctly copied = self.client.copy(max_retries=7) @@ -106,9 +101,7 @@ def test_copy_default_options(self) -> None: assert isinstance(self.client.timeout, httpx.Timeout) def test_copy_default_headers(self) -> None: - client = Agentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} - ) + client = Agentex(base_url=base_url, _strict_response_validation=True, default_headers={"X-Foo": "bar"}) assert client.default_headers["X-Foo"] == "bar" # does not override the already given value when not specified @@ -140,9 +133,7 @@ def test_copy_default_headers(self) -> None: client.copy(set_default_headers={}, default_headers={"X-Foo": "Bar"}) def test_copy_default_query(self) -> None: - client = Agentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"foo": "bar"} - ) + client = Agentex(base_url=base_url, _strict_response_validation=True, default_query={"foo": "bar"}) assert _get_params(client)["foo"] == "bar" # does not override the already given value when not specified @@ -266,7 +257,7 @@ def test_request_timeout(self) -> None: assert timeout == httpx.Timeout(100.0) def test_client_timeout_option(self) -> None: - client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True, timeout=httpx.Timeout(0)) + client = Agentex(base_url=base_url, _strict_response_validation=True, timeout=httpx.Timeout(0)) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -275,9 +266,7 @@ def test_client_timeout_option(self) -> None: def test_http_client_timeout_option(self) -> None: # custom timeout given to the httpx client should be used with httpx.Client(timeout=None) as http_client: - client = Agentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client - ) + client = Agentex(base_url=base_url, _strict_response_validation=True, http_client=http_client) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -285,9 +274,7 @@ def test_http_client_timeout_option(self) -> None: # no timeout given to the httpx client should not use the httpx default with httpx.Client() as http_client: - client = Agentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client - ) + client = Agentex(base_url=base_url, _strict_response_validation=True, http_client=http_client) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -295,9 +282,7 @@ def test_http_client_timeout_option(self) -> None: # explicitly passing the default timeout currently results in it being ignored with httpx.Client(timeout=HTTPX_DEFAULT_TIMEOUT) as http_client: - client = Agentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client - ) + client = Agentex(base_url=base_url, _strict_response_validation=True, http_client=http_client) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -306,24 +291,16 @@ def test_http_client_timeout_option(self) -> None: async def test_invalid_http_client(self) -> None: with pytest.raises(TypeError, match="Invalid `http_client` arg"): async with httpx.AsyncClient() as http_client: - Agentex( - base_url=base_url, - api_key=api_key, - _strict_response_validation=True, - http_client=cast(Any, http_client), - ) + Agentex(base_url=base_url, _strict_response_validation=True, http_client=cast(Any, http_client)) def test_default_headers_option(self) -> None: - client = Agentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} - ) + client = Agentex(base_url=base_url, _strict_response_validation=True, default_headers={"X-Foo": "bar"}) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) assert request.headers.get("x-foo") == "bar" assert request.headers.get("x-stainless-lang") == "python" client2 = Agentex( base_url=base_url, - api_key=api_key, _strict_response_validation=True, default_headers={ "X-Foo": "stainless", @@ -334,29 +311,8 @@ def test_default_headers_option(self) -> None: assert request.headers.get("x-foo") == "stainless" assert request.headers.get("x-stainless-lang") == "my-overriding-header" - def test_validate_headers(self) -> None: - client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) - request = client._build_request(FinalRequestOptions(method="get", url="/foo")) - assert request.headers.get("Authorization") == f"Bearer {api_key}" - - with update_env(**{"AGENTEX_SDK_API_KEY": Omit()}): - client2 = Agentex(base_url=base_url, api_key=None, _strict_response_validation=True) - - with pytest.raises( - TypeError, - match="Could not resolve authentication method. Expected the api_key to be set. Or for the `Authorization` headers to be explicitly omitted", - ): - client2._build_request(FinalRequestOptions(method="get", url="/foo")) - - request2 = client2._build_request( - FinalRequestOptions(method="get", url="/foo", headers={"Authorization": Omit()}) - ) - assert request2.headers.get("Authorization") is None - def test_default_query_option(self) -> None: - client = Agentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"query_param": "bar"} - ) + client = Agentex(base_url=base_url, _strict_response_validation=True, default_query={"query_param": "bar"}) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) url = httpx.URL(request.url) assert dict(url.params) == {"query_param": "bar"} @@ -555,7 +511,7 @@ class Model(BaseModel): assert response.foo == 2 def test_base_url_setter(self) -> None: - client = Agentex(base_url="https://example.com/from_init", api_key=api_key, _strict_response_validation=True) + client = Agentex(base_url="https://example.com/from_init", _strict_response_validation=True) assert client.base_url == "https://example.com/from_init/" client.base_url = "https://example.com/from_setter" # type: ignore[assignment] @@ -564,16 +520,23 @@ def test_base_url_setter(self) -> None: def test_base_url_env(self) -> None: with update_env(AGENTEX_BASE_URL="http://localhost:5000/from/env"): - client = Agentex(api_key=api_key, _strict_response_validation=True) + client = Agentex(_strict_response_validation=True) assert client.base_url == "http://localhost:5000/from/env/" + # explicit environment arg requires explicitness + with update_env(AGENTEX_BASE_URL="http://localhost:5000/from/env"): + with pytest.raises(ValueError, match=r"you must pass base_url=None"): + Agentex(_strict_response_validation=True, environment="production") + + client = Agentex(base_url=None, _strict_response_validation=True, environment="production") + assert str(client.base_url).startswith("http://localhost:5003") + @pytest.mark.parametrize( "client", [ - Agentex(base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True), + Agentex(base_url="http://localhost:5000/custom/path/", _strict_response_validation=True), Agentex( base_url="http://localhost:5000/custom/path/", - api_key=api_key, _strict_response_validation=True, http_client=httpx.Client(), ), @@ -593,10 +556,9 @@ def test_base_url_trailing_slash(self, client: Agentex) -> None: @pytest.mark.parametrize( "client", [ - Agentex(base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True), + Agentex(base_url="http://localhost:5000/custom/path/", _strict_response_validation=True), Agentex( base_url="http://localhost:5000/custom/path/", - api_key=api_key, _strict_response_validation=True, http_client=httpx.Client(), ), @@ -616,10 +578,9 @@ def test_base_url_no_trailing_slash(self, client: Agentex) -> None: @pytest.mark.parametrize( "client", [ - Agentex(base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True), + Agentex(base_url="http://localhost:5000/custom/path/", _strict_response_validation=True), Agentex( base_url="http://localhost:5000/custom/path/", - api_key=api_key, _strict_response_validation=True, http_client=httpx.Client(), ), @@ -637,7 +598,7 @@ def test_absolute_request_url(self, client: Agentex) -> None: assert request.url == "https://myapi.com/foo" def test_copied_client_does_not_close_http(self) -> None: - client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = Agentex(base_url=base_url, _strict_response_validation=True) assert not client.is_closed() copied = client.copy() @@ -648,7 +609,7 @@ def test_copied_client_does_not_close_http(self) -> None: assert not client.is_closed() def test_client_context_manager(self) -> None: - client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = Agentex(base_url=base_url, _strict_response_validation=True) with client as c2: assert c2 is client assert not c2.is_closed() @@ -669,7 +630,7 @@ class Model(BaseModel): def test_client_max_retries_validation(self) -> None: with pytest.raises(TypeError, match=r"max_retries cannot be None"): - Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True, max_retries=cast(Any, None)) + Agentex(base_url=base_url, _strict_response_validation=True, max_retries=cast(Any, None)) @pytest.mark.respx(base_url=base_url) def test_received_text_for_expected_json(self, respx_mock: MockRouter) -> None: @@ -678,12 +639,12 @@ class Model(BaseModel): respx_mock.get("/foo").mock(return_value=httpx.Response(200, text="my-custom-format")) - strict_client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + strict_client = Agentex(base_url=base_url, _strict_response_validation=True) with pytest.raises(APIResponseValidationError): strict_client.get("/foo", cast_to=Model) - client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=False) + client = Agentex(base_url=base_url, _strict_response_validation=False) response = client.get("/foo", cast_to=Model) assert isinstance(response, str) # type: ignore[unreachable] @@ -711,7 +672,7 @@ class Model(BaseModel): ) @mock.patch("time.time", mock.MagicMock(return_value=1696004797)) def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str, timeout: float) -> None: - client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = Agentex(base_url=base_url, _strict_response_validation=True) headers = httpx.Headers({"retry-after": retry_after}) options = FinalRequestOptions(method="get", url="/foo", max_retries=3) @@ -721,20 +682,20 @@ def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter, client: Agentex) -> None: - respx_mock.post("/echo").mock(side_effect=httpx.TimeoutException("Test timeout error")) + respx_mock.get("/agents/agent_id").mock(side_effect=httpx.TimeoutException("Test timeout error")) with pytest.raises(APITimeoutError): - client.echo.with_streaming_response.send(message="message").__enter__() + client.agents.with_streaming_response.retrieve("agent_id").__enter__() assert _get_open_connections(self.client) == 0 @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, client: Agentex) -> None: - respx_mock.post("/echo").mock(return_value=httpx.Response(500)) + respx_mock.get("/agents/agent_id").mock(return_value=httpx.Response(500)) with pytest.raises(APIStatusError): - client.echo.with_streaming_response.send(message="message").__enter__() + client.agents.with_streaming_response.retrieve("agent_id").__enter__() assert _get_open_connections(self.client) == 0 @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) @@ -761,9 +722,9 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: return httpx.Response(500) return httpx.Response(200) - respx_mock.post("/echo").mock(side_effect=retry_handler) + respx_mock.get("/agents/agent_id").mock(side_effect=retry_handler) - response = client.echo.with_raw_response.send(message="message") + response = client.agents.with_raw_response.retrieve("agent_id") assert response.retries_taken == failures_before_success assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success @@ -785,10 +746,10 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: return httpx.Response(500) return httpx.Response(200) - respx_mock.post("/echo").mock(side_effect=retry_handler) + respx_mock.get("/agents/agent_id").mock(side_effect=retry_handler) - response = client.echo.with_raw_response.send( - message="message", extra_headers={"x-stainless-retry-count": Omit()} + response = client.agents.with_raw_response.retrieve( + "agent_id", extra_headers={"x-stainless-retry-count": Omit()} ) assert len(response.http_request.headers.get_list("x-stainless-retry-count")) == 0 @@ -810,11 +771,9 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: return httpx.Response(500) return httpx.Response(200) - respx_mock.post("/echo").mock(side_effect=retry_handler) + respx_mock.get("/agents/agent_id").mock(side_effect=retry_handler) - response = client.echo.with_raw_response.send( - message="message", extra_headers={"x-stainless-retry-count": "42"} - ) + response = client.agents.with_raw_response.retrieve("agent_id", extra_headers={"x-stainless-retry-count": "42"}) assert response.http_request.headers.get("x-stainless-retry-count") == "42" @@ -869,7 +828,7 @@ def test_follow_redirects_disabled(self, respx_mock: MockRouter) -> None: class TestAsyncAgentex: - client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = AsyncAgentex(base_url=base_url, _strict_response_validation=True) @pytest.mark.respx(base_url=base_url) @pytest.mark.asyncio @@ -897,10 +856,6 @@ def test_copy(self) -> None: copied = self.client.copy() assert id(copied) != id(self.client) - copied = self.client.copy(api_key="another My API Key") - assert copied.api_key == "another My API Key" - assert self.client.api_key == "My API Key" - def test_copy_default_options(self) -> None: # options that have a default are overridden correctly copied = self.client.copy(max_retries=7) @@ -918,9 +873,7 @@ def test_copy_default_options(self) -> None: assert isinstance(self.client.timeout, httpx.Timeout) def test_copy_default_headers(self) -> None: - client = AsyncAgentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} - ) + client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, default_headers={"X-Foo": "bar"}) assert client.default_headers["X-Foo"] == "bar" # does not override the already given value when not specified @@ -952,9 +905,7 @@ def test_copy_default_headers(self) -> None: client.copy(set_default_headers={}, default_headers={"X-Foo": "Bar"}) def test_copy_default_query(self) -> None: - client = AsyncAgentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"foo": "bar"} - ) + client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, default_query={"foo": "bar"}) assert _get_params(client)["foo"] == "bar" # does not override the already given value when not specified @@ -1078,9 +1029,7 @@ async def test_request_timeout(self) -> None: assert timeout == httpx.Timeout(100.0) async def test_client_timeout_option(self) -> None: - client = AsyncAgentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, timeout=httpx.Timeout(0) - ) + client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, timeout=httpx.Timeout(0)) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -1089,9 +1038,7 @@ async def test_client_timeout_option(self) -> None: async def test_http_client_timeout_option(self) -> None: # custom timeout given to the httpx client should be used async with httpx.AsyncClient(timeout=None) as http_client: - client = AsyncAgentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client - ) + client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, http_client=http_client) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -1099,9 +1046,7 @@ async def test_http_client_timeout_option(self) -> None: # no timeout given to the httpx client should not use the httpx default async with httpx.AsyncClient() as http_client: - client = AsyncAgentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client - ) + client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, http_client=http_client) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -1109,9 +1054,7 @@ async def test_http_client_timeout_option(self) -> None: # explicitly passing the default timeout currently results in it being ignored async with httpx.AsyncClient(timeout=HTTPX_DEFAULT_TIMEOUT) as http_client: - client = AsyncAgentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client - ) + client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, http_client=http_client) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -1120,24 +1063,16 @@ async def test_http_client_timeout_option(self) -> None: def test_invalid_http_client(self) -> None: with pytest.raises(TypeError, match="Invalid `http_client` arg"): with httpx.Client() as http_client: - AsyncAgentex( - base_url=base_url, - api_key=api_key, - _strict_response_validation=True, - http_client=cast(Any, http_client), - ) + AsyncAgentex(base_url=base_url, _strict_response_validation=True, http_client=cast(Any, http_client)) def test_default_headers_option(self) -> None: - client = AsyncAgentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} - ) + client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, default_headers={"X-Foo": "bar"}) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) assert request.headers.get("x-foo") == "bar" assert request.headers.get("x-stainless-lang") == "python" client2 = AsyncAgentex( base_url=base_url, - api_key=api_key, _strict_response_validation=True, default_headers={ "X-Foo": "stainless", @@ -1148,29 +1083,8 @@ def test_default_headers_option(self) -> None: assert request.headers.get("x-foo") == "stainless" assert request.headers.get("x-stainless-lang") == "my-overriding-header" - def test_validate_headers(self) -> None: - client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) - request = client._build_request(FinalRequestOptions(method="get", url="/foo")) - assert request.headers.get("Authorization") == f"Bearer {api_key}" - - with update_env(**{"AGENTEX_SDK_API_KEY": Omit()}): - client2 = AsyncAgentex(base_url=base_url, api_key=None, _strict_response_validation=True) - - with pytest.raises( - TypeError, - match="Could not resolve authentication method. Expected the api_key to be set. Or for the `Authorization` headers to be explicitly omitted", - ): - client2._build_request(FinalRequestOptions(method="get", url="/foo")) - - request2 = client2._build_request( - FinalRequestOptions(method="get", url="/foo", headers={"Authorization": Omit()}) - ) - assert request2.headers.get("Authorization") is None - def test_default_query_option(self) -> None: - client = AsyncAgentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"query_param": "bar"} - ) + client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, default_query={"query_param": "bar"}) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) url = httpx.URL(request.url) assert dict(url.params) == {"query_param": "bar"} @@ -1369,9 +1283,7 @@ class Model(BaseModel): assert response.foo == 2 def test_base_url_setter(self) -> None: - client = AsyncAgentex( - base_url="https://example.com/from_init", api_key=api_key, _strict_response_validation=True - ) + client = AsyncAgentex(base_url="https://example.com/from_init", _strict_response_validation=True) assert client.base_url == "https://example.com/from_init/" client.base_url = "https://example.com/from_setter" # type: ignore[assignment] @@ -1380,18 +1292,23 @@ def test_base_url_setter(self) -> None: def test_base_url_env(self) -> None: with update_env(AGENTEX_BASE_URL="http://localhost:5000/from/env"): - client = AsyncAgentex(api_key=api_key, _strict_response_validation=True) + client = AsyncAgentex(_strict_response_validation=True) assert client.base_url == "http://localhost:5000/from/env/" + # explicit environment arg requires explicitness + with update_env(AGENTEX_BASE_URL="http://localhost:5000/from/env"): + with pytest.raises(ValueError, match=r"you must pass base_url=None"): + AsyncAgentex(_strict_response_validation=True, environment="production") + + client = AsyncAgentex(base_url=None, _strict_response_validation=True, environment="production") + assert str(client.base_url).startswith("http://localhost:5003") + @pytest.mark.parametrize( "client", [ - AsyncAgentex( - base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True - ), + AsyncAgentex(base_url="http://localhost:5000/custom/path/", _strict_response_validation=True), AsyncAgentex( base_url="http://localhost:5000/custom/path/", - api_key=api_key, _strict_response_validation=True, http_client=httpx.AsyncClient(), ), @@ -1411,12 +1328,9 @@ def test_base_url_trailing_slash(self, client: AsyncAgentex) -> None: @pytest.mark.parametrize( "client", [ - AsyncAgentex( - base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True - ), + AsyncAgentex(base_url="http://localhost:5000/custom/path/", _strict_response_validation=True), AsyncAgentex( base_url="http://localhost:5000/custom/path/", - api_key=api_key, _strict_response_validation=True, http_client=httpx.AsyncClient(), ), @@ -1436,12 +1350,9 @@ def test_base_url_no_trailing_slash(self, client: AsyncAgentex) -> None: @pytest.mark.parametrize( "client", [ - AsyncAgentex( - base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True - ), + AsyncAgentex(base_url="http://localhost:5000/custom/path/", _strict_response_validation=True), AsyncAgentex( base_url="http://localhost:5000/custom/path/", - api_key=api_key, _strict_response_validation=True, http_client=httpx.AsyncClient(), ), @@ -1459,7 +1370,7 @@ def test_absolute_request_url(self, client: AsyncAgentex) -> None: assert request.url == "https://myapi.com/foo" async def test_copied_client_does_not_close_http(self) -> None: - client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = AsyncAgentex(base_url=base_url, _strict_response_validation=True) assert not client.is_closed() copied = client.copy() @@ -1471,7 +1382,7 @@ async def test_copied_client_does_not_close_http(self) -> None: assert not client.is_closed() async def test_client_context_manager(self) -> None: - client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = AsyncAgentex(base_url=base_url, _strict_response_validation=True) async with client as c2: assert c2 is client assert not c2.is_closed() @@ -1493,9 +1404,7 @@ class Model(BaseModel): async def test_client_max_retries_validation(self) -> None: with pytest.raises(TypeError, match=r"max_retries cannot be None"): - AsyncAgentex( - base_url=base_url, api_key=api_key, _strict_response_validation=True, max_retries=cast(Any, None) - ) + AsyncAgentex(base_url=base_url, _strict_response_validation=True, max_retries=cast(Any, None)) @pytest.mark.respx(base_url=base_url) @pytest.mark.asyncio @@ -1505,12 +1414,12 @@ class Model(BaseModel): respx_mock.get("/foo").mock(return_value=httpx.Response(200, text="my-custom-format")) - strict_client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + strict_client = AsyncAgentex(base_url=base_url, _strict_response_validation=True) with pytest.raises(APIResponseValidationError): await strict_client.get("/foo", cast_to=Model) - client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=False) + client = AsyncAgentex(base_url=base_url, _strict_response_validation=False) response = await client.get("/foo", cast_to=Model) assert isinstance(response, str) # type: ignore[unreachable] @@ -1539,7 +1448,7 @@ class Model(BaseModel): @mock.patch("time.time", mock.MagicMock(return_value=1696004797)) @pytest.mark.asyncio async def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str, timeout: float) -> None: - client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + client = AsyncAgentex(base_url=base_url, _strict_response_validation=True) headers = httpx.Headers({"retry-after": retry_after}) options = FinalRequestOptions(method="get", url="/foo", max_retries=3) @@ -1551,20 +1460,20 @@ async def test_parse_retry_after_header(self, remaining_retries: int, retry_afte async def test_retrying_timeout_errors_doesnt_leak( self, respx_mock: MockRouter, async_client: AsyncAgentex ) -> None: - respx_mock.post("/echo").mock(side_effect=httpx.TimeoutException("Test timeout error")) + respx_mock.get("/agents/agent_id").mock(side_effect=httpx.TimeoutException("Test timeout error")) with pytest.raises(APITimeoutError): - await async_client.echo.with_streaming_response.send(message="message").__aenter__() + await async_client.agents.with_streaming_response.retrieve("agent_id").__aenter__() assert _get_open_connections(self.client) == 0 @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) async def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, async_client: AsyncAgentex) -> None: - respx_mock.post("/echo").mock(return_value=httpx.Response(500)) + respx_mock.get("/agents/agent_id").mock(return_value=httpx.Response(500)) with pytest.raises(APIStatusError): - await async_client.echo.with_streaming_response.send(message="message").__aenter__() + await async_client.agents.with_streaming_response.retrieve("agent_id").__aenter__() assert _get_open_connections(self.client) == 0 @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) @@ -1592,9 +1501,9 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: return httpx.Response(500) return httpx.Response(200) - respx_mock.post("/echo").mock(side_effect=retry_handler) + respx_mock.get("/agents/agent_id").mock(side_effect=retry_handler) - response = await client.echo.with_raw_response.send(message="message") + response = await client.agents.with_raw_response.retrieve("agent_id") assert response.retries_taken == failures_before_success assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success @@ -1617,10 +1526,10 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: return httpx.Response(500) return httpx.Response(200) - respx_mock.post("/echo").mock(side_effect=retry_handler) + respx_mock.get("/agents/agent_id").mock(side_effect=retry_handler) - response = await client.echo.with_raw_response.send( - message="message", extra_headers={"x-stainless-retry-count": Omit()} + response = await client.agents.with_raw_response.retrieve( + "agent_id", extra_headers={"x-stainless-retry-count": Omit()} ) assert len(response.http_request.headers.get_list("x-stainless-retry-count")) == 0 @@ -1643,10 +1552,10 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: return httpx.Response(500) return httpx.Response(200) - respx_mock.post("/echo").mock(side_effect=retry_handler) + respx_mock.get("/agents/agent_id").mock(side_effect=retry_handler) - response = await client.echo.with_raw_response.send( - message="message", extra_headers={"x-stainless-retry-count": "42"} + response = await client.agents.with_raw_response.retrieve( + "agent_id", extra_headers={"x-stainless-retry-count": "42"} ) assert response.http_request.headers.get("x-stainless-retry-count") == "42" From 5d44203fbb42d06df6b37131bcff785009a7e81c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 22 Jul 2025 01:38:14 +0000 Subject: [PATCH 0024/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 55f722d9..ba6c3483 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.0.1-alpha.1" + ".": "0.1.0-alpha.1" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 2769d9ca..41d89021 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex" -version = "0.0.1-alpha.1" +version = "0.1.0-alpha.1" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 3b76e3fe..5afa0a71 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.0.1-alpha.1" # x-release-please-version +__version__ = "0.1.0-alpha.1" # x-release-please-version From 65bb06fbd79d0b92175857c69a3b93a2add835c7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 22 Jul 2025 01:47:13 +0000 Subject: [PATCH 0025/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index ba6c3483..f14b480a 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.1.0-alpha.1" + ".": "0.1.0-alpha.2" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 41d89021..c45e242b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex" -version = "0.1.0-alpha.1" +version = "0.1.0-alpha.2" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 5afa0a71..ac8955e6 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.1.0-alpha.1" # x-release-please-version +__version__ = "0.1.0-alpha.2" # x-release-please-version From d7819e0381a8fb64b29fe68966ee74f3c7b1b5a2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 22 Jul 2025 02:23:55 +0000 Subject: [PATCH 0026/1108] feat(api): api update --- .stats.yml | 4 +- api.md | 22 +---- src/agentex/resources/agents.py | 36 +++----- src/agentex/resources/messages/batch.py | 9 +- src/agentex/resources/messages/messages.py | 21 +++-- src/agentex/types/__init__.py | 10 +-- src/agentex/types/agent_rpc_by_name_params.py | 76 ++++++++++++++-- src/agentex/types/agent_rpc_params.py | 54 ++++++++--- src/agentex/types/agent_rpc_params1.py | 21 ----- src/agentex/types/agent_rpc_response.py | 20 ----- src/agentex/types/agent_rpc_result.py | 90 ------------------- src/agentex/types/data_delta.py | 14 --- src/agentex/types/event.py | 17 +++- src/agentex/types/message_create_params.py | 19 ++-- src/agentex/types/message_update_params.py | 19 ++-- .../types/messages/batch_create_params.py | 16 ++-- .../types/messages/batch_update_params.py | 16 ++-- src/agentex/types/streaming_status.py | 7 ++ src/agentex/types/task_message.py | 37 ++++---- src/agentex/types/task_message_content.py | 16 ---- .../types/task_message_content_param.py | 17 ---- src/agentex/types/task_message_delta.py | 16 ---- src/agentex/types/text_delta.py | 14 --- src/agentex/types/tool_request_delta.py | 18 ---- src/agentex/types/tool_response_delta.py | 18 ---- tests/api_resources/test_agents.py | 38 ++++---- 26 files changed, 253 insertions(+), 392 deletions(-) delete mode 100644 src/agentex/types/agent_rpc_params1.py delete mode 100644 src/agentex/types/agent_rpc_response.py delete mode 100644 src/agentex/types/agent_rpc_result.py delete mode 100644 src/agentex/types/data_delta.py create mode 100644 src/agentex/types/streaming_status.py delete mode 100644 src/agentex/types/task_message_content.py delete mode 100644 src/agentex/types/task_message_content_param.py delete mode 100644 src/agentex/types/task_message_delta.py delete mode 100644 src/agentex/types/text_delta.py delete mode 100644 src/agentex/types/tool_request_delta.py delete mode 100644 src/agentex/types/tool_response_delta.py diff --git a/.stats.yml b/.stats.yml index 2aac9130..91523e16 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1d08fb2290b5310c91801d7575d356628d372fd5434e15d3b9cead48eadb893f.yml -openapi_spec_hash: 216a0edbf4e1a3cde23329d4f385faed +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-021b55c88964b7a5bfc9d692d32a52c6b0150445656d2407c4cb8e9dd1e5f100.yml +openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 config_hash: 7661726e3cccf9f6349179841153601d diff --git a/api.md b/api.md index 8d4e6156..8c2841ca 100644 --- a/api.md +++ b/api.md @@ -3,22 +3,7 @@ Types: ```python -from agentex.types import ( - AcpType, - Agent, - AgentRpcParams, - AgentRpcRequest, - AgentRpcResponse, - AgentRpcResult, - DataDelta, - TaskMessageContent, - TaskMessageDelta, - TaskMessageUpdate, - TextDelta, - ToolRequestDelta, - ToolResponseDelta, - AgentListResponse, -) +from agentex.types import AcpType, Agent, AgentRpcRequest, AgentListResponse ``` Methods: @@ -28,8 +13,8 @@ Methods: - client.agents.delete(agent_id) -> Agent - client.agents.delete_by_name(agent_name) -> Agent - client.agents.retrieve_by_name(agent_name) -> Agent -- client.agents.rpc(agent_id, \*\*params) -> AgentRpcResponse -- client.agents.rpc_by_name(agent_name, \*\*params) -> AgentRpcResponse +- client.agents.rpc(agent_id, \*\*params) -> object +- client.agents.rpc_by_name(agent_name, \*\*params) -> object # Tasks @@ -58,6 +43,7 @@ from agentex.types import ( DataContent, MessageAuthor, MessageStyle, + StreamingStatus, TaskMessage, TextContent, ToolRequestContent, diff --git a/src/agentex/resources/agents.py b/src/agentex/resources/agents.py index 8b329be8..9c2e4bd5 100644 --- a/src/agentex/resources/agents.py +++ b/src/agentex/resources/agents.py @@ -7,7 +7,7 @@ import httpx -from ..types import AgentRpcParams, agent_rpc_params, agent_list_params, agent_rpc_by_name_params +from ..types import agent_rpc_params, agent_list_params, agent_rpc_by_name_params from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property @@ -20,8 +20,6 @@ ) from ..types.agent import Agent from .._base_client import make_request_options -from ..types.agent_rpc_params import AgentRpcParams -from ..types.agent_rpc_response import AgentRpcResponse from ..types.agent_list_response import AgentListResponse __all__ = ["AgentsResource", "AsyncAgentsResource"] @@ -221,7 +219,7 @@ def rpc( agent_id: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: AgentRpcParams, + params: agent_rpc_params.Params, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -230,13 +228,11 @@ def rpc( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> AgentRpcResponse: + ) -> object: """ Handle JSON-RPC requests for an agent by its unique ID. Args: - params: The parameters for the agent RPC request - extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -261,7 +257,7 @@ def rpc( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AgentRpcResponse, + cast_to=object, ) def rpc_by_name( @@ -269,7 +265,7 @@ def rpc_by_name( agent_name: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: AgentRpcParams, + params: agent_rpc_by_name_params.Params, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -278,13 +274,11 @@ def rpc_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> AgentRpcResponse: + ) -> object: """ Handle JSON-RPC requests for an agent by its unique name. Args: - params: The parameters for the agent RPC request - extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -309,7 +303,7 @@ def rpc_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AgentRpcResponse, + cast_to=object, ) @@ -507,7 +501,7 @@ async def rpc( agent_id: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: AgentRpcParams, + params: agent_rpc_params.Params, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -516,13 +510,11 @@ async def rpc( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> AgentRpcResponse: + ) -> object: """ Handle JSON-RPC requests for an agent by its unique ID. Args: - params: The parameters for the agent RPC request - extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -547,7 +539,7 @@ async def rpc( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AgentRpcResponse, + cast_to=object, ) async def rpc_by_name( @@ -555,7 +547,7 @@ async def rpc_by_name( agent_name: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: AgentRpcParams, + params: agent_rpc_by_name_params.Params, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -564,13 +556,11 @@ async def rpc_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> AgentRpcResponse: + ) -> object: """ Handle JSON-RPC requests for an agent by its unique name. Args: - params: The parameters for the agent RPC request - extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -595,7 +585,7 @@ async def rpc_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AgentRpcResponse, + cast_to=object, ) diff --git a/src/agentex/resources/messages/batch.py b/src/agentex/resources/messages/batch.py index 58412663..478c2df5 100644 --- a/src/agentex/resources/messages/batch.py +++ b/src/agentex/resources/messages/batch.py @@ -18,7 +18,6 @@ ) from ..._base_client import make_request_options from ...types.messages import batch_create_params, batch_update_params -from ...types.task_message_content_param import TaskMessageContentParam from ...types.messages.batch_create_response import BatchCreateResponse from ...types.messages.batch_update_response import BatchUpdateResponse @@ -48,7 +47,7 @@ def with_streaming_response(self) -> BatchResourceWithStreamingResponse: def create( self, *, - contents: Iterable[TaskMessageContentParam], + contents: Iterable[batch_create_params.Content], task_id: str, # 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. @@ -88,7 +87,7 @@ def update( self, *, task_id: str, - updates: Dict[str, TaskMessageContentParam], + updates: Dict[str, batch_update_params.Updates], # 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, @@ -147,7 +146,7 @@ def with_streaming_response(self) -> AsyncBatchResourceWithStreamingResponse: async def create( self, *, - contents: Iterable[TaskMessageContentParam], + contents: Iterable[batch_create_params.Content], task_id: str, # 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. @@ -187,7 +186,7 @@ async def update( self, *, task_id: str, - updates: Dict[str, TaskMessageContentParam], + updates: Dict[str, batch_update_params.Updates], # 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, diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index b7f78c94..7745cf76 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -3,7 +3,6 @@ from __future__ import annotations from typing import Optional -from typing_extensions import Literal import httpx @@ -15,7 +14,7 @@ BatchResourceWithStreamingResponse, AsyncBatchResourceWithStreamingResponse, ) -from ...types import message_list_params, message_create_params, message_update_params +from ...types import StreamingStatus, message_list_params, message_create_params, message_update_params from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property @@ -28,8 +27,8 @@ ) from ..._base_client import make_request_options from ...types.task_message import TaskMessage +from ...types.streaming_status import StreamingStatus from ...types.message_list_response import MessageListResponse -from ...types.task_message_content_param import TaskMessageContentParam __all__ = ["MessagesResource", "AsyncMessagesResource"] @@ -61,9 +60,9 @@ def with_streaming_response(self) -> MessagesResourceWithStreamingResponse: def create( self, *, - content: TaskMessageContentParam, + content: message_create_params.Content, task_id: str, - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, + streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, # 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, @@ -136,9 +135,9 @@ def update( self, message_id: str, *, - content: TaskMessageContentParam, + content: message_update_params.Content, task_id: str, - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, + streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, # 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, @@ -246,9 +245,9 @@ def with_streaming_response(self) -> AsyncMessagesResourceWithStreamingResponse: async def create( self, *, - content: TaskMessageContentParam, + content: message_create_params.Content, task_id: str, - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, + streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, # 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, @@ -321,9 +320,9 @@ async def update( self, message_id: str, *, - content: TaskMessageContentParam, + content: message_update_params.Content, task_id: str, - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, + streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, # 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, diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 26d1ecc8..a5e72143 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -8,38 +8,31 @@ from .event import Event as Event from .state import State as State from .acp_type import AcpType as AcpType -from .data_delta import DataDelta as DataDelta -from .text_delta import TextDelta as TextDelta from .data_content import DataContent as DataContent from .task_message import TaskMessage as TaskMessage from .text_content import TextContent as TextContent from .message_style import MessageStyle as MessageStyle from .message_author import MessageAuthor as MessageAuthor from .agent_rpc_params import AgentRpcParams as AgentRpcParams -from .agent_rpc_result import AgentRpcResult as AgentRpcResult from .span_list_params import SpanListParams as SpanListParams +from .streaming_status import StreamingStatus as StreamingStatus from .agent_list_params import AgentListParams as AgentListParams from .event_list_params import EventListParams as EventListParams from .state_list_params import StateListParams as StateListParams -from .agent_rpc_response import AgentRpcResponse as AgentRpcResponse from .agent_task_tracker import AgentTaskTracker as AgentTaskTracker from .data_content_param import DataContentParam as DataContentParam from .span_create_params import SpanCreateParams as SpanCreateParams from .span_list_response import SpanListResponse as SpanListResponse from .span_update_params import SpanUpdateParams as SpanUpdateParams from .task_list_response import TaskListResponse as TaskListResponse -from .task_message_delta import TaskMessageDelta as TaskMessageDelta from .text_content_param import TextContentParam as TextContentParam -from .tool_request_delta import ToolRequestDelta as ToolRequestDelta from .agent_list_response import AgentListResponse as AgentListResponse from .event_list_response import EventListResponse as EventListResponse from .message_list_params import MessageListParams as MessageListParams from .state_create_params import StateCreateParams as StateCreateParams from .state_list_response import StateListResponse as StateListResponse from .state_update_params import StateUpdateParams as StateUpdateParams -from .tool_response_delta import ToolResponseDelta as ToolResponseDelta from .tracker_list_params import TrackerListParams as TrackerListParams -from .task_message_content import TaskMessageContent as TaskMessageContent from .tool_request_content import ToolRequestContent as ToolRequestContent from .message_create_params import MessageCreateParams as MessageCreateParams from .message_list_response import MessageListResponse as MessageListResponse @@ -48,6 +41,5 @@ from .tracker_list_response import TrackerListResponse as TrackerListResponse from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams from .agent_rpc_by_name_params import AgentRpcByNameParams as AgentRpcByNameParams -from .task_message_content_param import TaskMessageContentParam as TaskMessageContentParam from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam diff --git a/src/agentex/types/agent_rpc_by_name_params.py b/src/agentex/types/agent_rpc_by_name_params.py index 5be189d7..5014a076 100644 --- a/src/agentex/types/agent_rpc_by_name_params.py +++ b/src/agentex/types/agent_rpc_by_name_params.py @@ -2,20 +2,84 @@ from __future__ import annotations -from typing import Union -from typing_extensions import Literal, Required, TypedDict +from typing import Dict, Union, Optional +from typing_extensions import Literal, Required, TypeAlias, TypedDict -from .agent_rpc_params import AgentRpcParams +from .data_content_param import DataContentParam +from .text_content_param import TextContentParam +from .tool_request_content_param import ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam -__all__ = ["AgentRpcByNameParams"] +__all__ = [ + "AgentRpcByNameParams", + "Params", + "ParamsCreateTaskRequest", + "ParamsCancelTaskRequest", + "ParamsSendMessageRequest", + "ParamsSendMessageRequestContent", + "ParamsSendEventRequest", + "ParamsSendEventRequestContent", +] class AgentRpcByNameParams(TypedDict, total=False): method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] - params: Required[AgentRpcParams] - """The parameters for the agent RPC request""" + params: Required[Params] id: Union[int, str, None] jsonrpc: Literal["2.0"] + + +class ParamsCreateTaskRequest(TypedDict, total=False): + name: Optional[str] + """The name of the task to create""" + + params: Optional[Dict[str, object]] + """The parameters for the task""" + + +class ParamsCancelTaskRequest(TypedDict, total=False): + task_id: Optional[str] + """The ID of the task to cancel. Either this or task_name must be provided.""" + + task_name: Optional[str] + """The name of the task to cancel. Either this or task_id must be provided.""" + + +ParamsSendMessageRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendMessageRequest(TypedDict, total=False): + content: Required[ParamsSendMessageRequestContent] + """The message that was sent to the agent""" + + stream: bool + """Whether to stream the response message back to the client""" + + task_id: Optional[str] + """The ID of the task that the message was sent to""" + + +ParamsSendEventRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendEventRequest(TypedDict, total=False): + content: Optional[ParamsSendEventRequestContent] + """The content to send to the event""" + + task_id: Optional[str] + """The ID of the task that the event was sent to""" + + task_name: Optional[str] + """The name of the task that the event was sent to""" + + +Params: TypeAlias = Union[ + ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest +] diff --git a/src/agentex/types/agent_rpc_params.py b/src/agentex/types/agent_rpc_params.py index 5082b18c..2c79a7a9 100644 --- a/src/agentex/types/agent_rpc_params.py +++ b/src/agentex/types/agent_rpc_params.py @@ -3,14 +3,36 @@ from __future__ import annotations from typing import Dict, Union, Optional -from typing_extensions import Required, TypeAlias, TypedDict +from typing_extensions import Literal, Required, TypeAlias, TypedDict -from .task_message_content_param import TaskMessageContentParam +from .data_content_param import DataContentParam +from .text_content_param import TextContentParam +from .tool_request_content_param import ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam -__all__ = ["AgentRpcParams", "CreateTaskRequest", "CancelTaskRequest", "SendMessageRequest", "SendEventRequest"] +__all__ = [ + "AgentRpcParams", + "Params", + "ParamsCreateTaskRequest", + "ParamsCancelTaskRequest", + "ParamsSendMessageRequest", + "ParamsSendMessageRequestContent", + "ParamsSendEventRequest", + "ParamsSendEventRequestContent", +] -class CreateTaskRequest(TypedDict, total=False): +class AgentRpcParams(TypedDict, total=False): + method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] + + params: Required[Params] + + id: Union[int, str, None] + + jsonrpc: Literal["2.0"] + + +class ParamsCreateTaskRequest(TypedDict, total=False): name: Optional[str] """The name of the task to create""" @@ -18,7 +40,7 @@ class CreateTaskRequest(TypedDict, total=False): """The parameters for the task""" -class CancelTaskRequest(TypedDict, total=False): +class ParamsCancelTaskRequest(TypedDict, total=False): task_id: Optional[str] """The ID of the task to cancel. Either this or task_name must be provided.""" @@ -26,8 +48,13 @@ class CancelTaskRequest(TypedDict, total=False): """The name of the task to cancel. Either this or task_id must be provided.""" -class SendMessageRequest(TypedDict, total=False): - content: Required[TaskMessageContentParam] +ParamsSendMessageRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendMessageRequest(TypedDict, total=False): + content: Required[ParamsSendMessageRequestContent] """The message that was sent to the agent""" stream: bool @@ -37,8 +64,13 @@ class SendMessageRequest(TypedDict, total=False): """The ID of the task that the message was sent to""" -class SendEventRequest(TypedDict, total=False): - content: Optional[TaskMessageContentParam] +ParamsSendEventRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendEventRequest(TypedDict, total=False): + content: Optional[ParamsSendEventRequestContent] """The content to send to the event""" task_id: Optional[str] @@ -48,4 +80,6 @@ class SendEventRequest(TypedDict, total=False): """The name of the task that the event was sent to""" -AgentRpcParams: TypeAlias = Union[CreateTaskRequest, CancelTaskRequest, SendMessageRequest, SendEventRequest] +Params: TypeAlias = Union[ + ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest +] diff --git a/src/agentex/types/agent_rpc_params1.py b/src/agentex/types/agent_rpc_params1.py deleted file mode 100644 index 3eae8b68..00000000 --- a/src/agentex/types/agent_rpc_params1.py +++ /dev/null @@ -1,21 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Union -from typing_extensions import Literal, Required, TypedDict - -from . import agent_rpc_params - -__all__ = ["AgentRpcParams"] - - -class AgentRpcParams(TypedDict, total=False): - method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] - - params: Required[agent_rpc_params.AgentRpcParams] - """The parameters for the agent RPC request""" - - id: Union[int, str, None] - - jsonrpc: Literal["2.0"] diff --git a/src/agentex/types/agent_rpc_response.py b/src/agentex/types/agent_rpc_response.py deleted file mode 100644 index e9995e80..00000000 --- a/src/agentex/types/agent_rpc_response.py +++ /dev/null @@ -1,20 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import Union, Optional -from typing_extensions import Literal - -from .._models import BaseModel -from .agent_rpc_result import AgentRpcResult - -__all__ = ["AgentRpcResponse"] - - -class AgentRpcResponse(BaseModel): - result: Optional[AgentRpcResult] = None - """The result of the agent RPC request""" - - id: Union[int, str, None] = None - - error: Optional[object] = None - - jsonrpc: Optional[Literal["2.0"]] = None diff --git a/src/agentex/types/agent_rpc_result.py b/src/agentex/types/agent_rpc_result.py deleted file mode 100644 index 63e30a5d..00000000 --- a/src/agentex/types/agent_rpc_result.py +++ /dev/null @@ -1,90 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import List, Union, Optional -from typing_extensions import Literal, TypeAlias - -from .task import Task -from .event import Event -from .._models import BaseModel -from .task_message import TaskMessage -from .task_message_delta import TaskMessageDelta -from .task_message_content import TaskMessageContent - -__all__ = [ - "AgentRpcResult", - "StreamTaskMessageStart", - "StreamTaskMessageDelta", - "StreamTaskMessageFull", - "StreamTaskMessageDone", -] - - -class StreamTaskMessageStart(BaseModel): - content: TaskMessageContent - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["start"]] = None - - -class StreamTaskMessageDelta(BaseModel): - delta: Optional[TaskMessageDelta] = None - """Delta for text updates""" - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["delta"]] = None - - -class StreamTaskMessageFull(BaseModel): - content: TaskMessageContent - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["full"]] = None - - -class StreamTaskMessageDone(BaseModel): - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["done"]] = None - - -AgentRpcResult: TypeAlias = Union[ - List[TaskMessage], - StreamTaskMessageStart, - StreamTaskMessageDelta, - StreamTaskMessageFull, - StreamTaskMessageDone, - Task, - Event, - None, -] diff --git a/src/agentex/types/data_delta.py b/src/agentex/types/data_delta.py deleted file mode 100644 index e30c12e7..00000000 --- a/src/agentex/types/data_delta.py +++ /dev/null @@ -1,14 +0,0 @@ -# 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__ = ["DataDelta"] - - -class DataDelta(BaseModel): - data_delta: Optional[str] = None - - type: Optional[Literal["data"]] = None diff --git a/src/agentex/types/event.py b/src/agentex/types/event.py index 9a544cb6..3f1e5997 100644 --- a/src/agentex/types/event.py +++ b/src/agentex/types/event.py @@ -1,12 +1,21 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Optional +from typing import Union, Optional from datetime import datetime +from typing_extensions import Annotated, TypeAlias +from .._utils import PropertyInfo from .._models import BaseModel -from .task_message_content import TaskMessageContent +from .data_content import DataContent +from .text_content import TextContent +from .tool_request_content import ToolRequestContent +from .tool_response_content import ToolResponseContent -__all__ = ["Event"] +__all__ = ["Event", "Content"] + +Content: TypeAlias = Annotated[ + Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent, None], PropertyInfo(discriminator="type") +] class Event(BaseModel): @@ -22,7 +31,7 @@ class Event(BaseModel): task_id: str """The UUID of the task that the event belongs to""" - content: Optional[TaskMessageContent] = None + content: Optional[Content] = None """The content of the event""" created_at: Optional[datetime] = None diff --git a/src/agentex/types/message_create_params.py b/src/agentex/types/message_create_params.py index 787715ec..06ec3727 100644 --- a/src/agentex/types/message_create_params.py +++ b/src/agentex/types/message_create_params.py @@ -2,17 +2,24 @@ from __future__ import annotations -from typing import Optional -from typing_extensions import Literal, Required, TypedDict +from typing import Union, Optional +from typing_extensions import Required, TypeAlias, TypedDict -from .task_message_content_param import TaskMessageContentParam +from .streaming_status import StreamingStatus +from .data_content_param import DataContentParam +from .text_content_param import TextContentParam +from .tool_request_content_param import ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam -__all__ = ["MessageCreateParams"] +__all__ = ["MessageCreateParams", "Content"] class MessageCreateParams(TypedDict, total=False): - content: Required[TaskMessageContentParam] + content: Required[Content] task_id: Required[str] - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] + streaming_status: Optional[StreamingStatus] + + +Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex/types/message_update_params.py b/src/agentex/types/message_update_params.py index ea3dbaf8..bc5305b8 100644 --- a/src/agentex/types/message_update_params.py +++ b/src/agentex/types/message_update_params.py @@ -2,17 +2,24 @@ from __future__ import annotations -from typing import Optional -from typing_extensions import Literal, Required, TypedDict +from typing import Union, Optional +from typing_extensions import Required, TypeAlias, TypedDict -from .task_message_content_param import TaskMessageContentParam +from .streaming_status import StreamingStatus +from .data_content_param import DataContentParam +from .text_content_param import TextContentParam +from .tool_request_content_param import ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam -__all__ = ["MessageUpdateParams"] +__all__ = ["MessageUpdateParams", "Content"] class MessageUpdateParams(TypedDict, total=False): - content: Required[TaskMessageContentParam] + content: Required[Content] task_id: Required[str] - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] + streaming_status: Optional[StreamingStatus] + + +Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex/types/messages/batch_create_params.py b/src/agentex/types/messages/batch_create_params.py index 0a0153ae..c09c69a9 100644 --- a/src/agentex/types/messages/batch_create_params.py +++ b/src/agentex/types/messages/batch_create_params.py @@ -2,15 +2,21 @@ from __future__ import annotations -from typing import Iterable -from typing_extensions import Required, TypedDict +from typing import Union, Iterable +from typing_extensions import Required, TypeAlias, TypedDict -from ..task_message_content_param import TaskMessageContentParam +from ..data_content_param import DataContentParam +from ..text_content_param import TextContentParam +from ..tool_request_content_param import ToolRequestContentParam +from ..tool_response_content_param import ToolResponseContentParam -__all__ = ["BatchCreateParams"] +__all__ = ["BatchCreateParams", "Content"] class BatchCreateParams(TypedDict, total=False): - contents: Required[Iterable[TaskMessageContentParam]] + contents: Required[Iterable[Content]] task_id: Required[str] + + +Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex/types/messages/batch_update_params.py b/src/agentex/types/messages/batch_update_params.py index c25e46f6..68f24f8d 100644 --- a/src/agentex/types/messages/batch_update_params.py +++ b/src/agentex/types/messages/batch_update_params.py @@ -2,15 +2,21 @@ from __future__ import annotations -from typing import Dict -from typing_extensions import Required, TypedDict +from typing import Dict, Union +from typing_extensions import Required, TypeAlias, TypedDict -from ..task_message_content_param import TaskMessageContentParam +from ..data_content_param import DataContentParam +from ..text_content_param import TextContentParam +from ..tool_request_content_param import ToolRequestContentParam +from ..tool_response_content_param import ToolResponseContentParam -__all__ = ["BatchUpdateParams"] +__all__ = ["BatchUpdateParams", "Updates"] class BatchUpdateParams(TypedDict, total=False): task_id: Required[str] - updates: Required[Dict[str, TaskMessageContentParam]] + updates: Required[Dict[str, Updates]] + + +Updates: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex/types/streaming_status.py b/src/agentex/types/streaming_status.py new file mode 100644 index 00000000..196d7881 --- /dev/null +++ b/src/agentex/types/streaming_status.py @@ -0,0 +1,7 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing_extensions import Literal, TypeAlias + +__all__ = ["StreamingStatus"] + +StreamingStatus: TypeAlias = Literal["IN_PROGRESS", "DONE"] diff --git a/src/agentex/types/task_message.py b/src/agentex/types/task_message.py index b5938cc8..686ade7d 100644 --- a/src/agentex/types/task_message.py +++ b/src/agentex/types/task_message.py @@ -1,33 +1,36 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Optional +from typing import Union, Optional from datetime import datetime -from typing_extensions import Literal +from typing_extensions import Annotated, TypeAlias +from .._utils import PropertyInfo from .._models import BaseModel -from .task_message_content import TaskMessageContent +from .data_content import DataContent +from .text_content import TextContent +from .streaming_status import StreamingStatus +from .tool_request_content import ToolRequestContent +from .tool_response_content import ToolResponseContent -__all__ = ["TaskMessage"] +__all__ = ["TaskMessage", "Content"] +Content: TypeAlias = Annotated[ + Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") +] -class TaskMessage(BaseModel): - content: TaskMessageContent - """The content of the message. - - This content is not OpenAI compatible. These are messages that are meant to be - displayed to the user. - """ - - task_id: str - """ID of the task this message belongs to""" - id: Optional[str] = None +class TaskMessage(BaseModel): + id: str """The task message's unique id""" - created_at: Optional[datetime] = None + content: Content + + created_at: datetime """The timestamp when the message was created""" - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] = None + task_id: str + + streaming_status: Optional[StreamingStatus] = None updated_at: Optional[datetime] = None """The timestamp when the message was last updated""" diff --git a/src/agentex/types/task_message_content.py b/src/agentex/types/task_message_content.py deleted file mode 100644 index 126992b4..00000000 --- a/src/agentex/types/task_message_content.py +++ /dev/null @@ -1,16 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import Union -from typing_extensions import Annotated, TypeAlias - -from .._utils import PropertyInfo -from .data_content import DataContent -from .text_content import TextContent -from .tool_request_content import ToolRequestContent -from .tool_response_content import ToolResponseContent - -__all__ = ["TaskMessageContent"] - -TaskMessageContent: TypeAlias = Annotated[ - Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") -] diff --git a/src/agentex/types/task_message_content_param.py b/src/agentex/types/task_message_content_param.py deleted file mode 100644 index 6991c64e..00000000 --- a/src/agentex/types/task_message_content_param.py +++ /dev/null @@ -1,17 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Union -from typing_extensions import TypeAlias - -from .data_content_param import DataContentParam -from .text_content_param import TextContentParam -from .tool_request_content_param import ToolRequestContentParam -from .tool_response_content_param import ToolResponseContentParam - -__all__ = ["TaskMessageContentParam"] - -TaskMessageContentParam: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] diff --git a/src/agentex/types/task_message_delta.py b/src/agentex/types/task_message_delta.py deleted file mode 100644 index 5a477e5a..00000000 --- a/src/agentex/types/task_message_delta.py +++ /dev/null @@ -1,16 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import Union -from typing_extensions import Annotated, TypeAlias - -from .._utils import PropertyInfo -from .data_delta import DataDelta -from .text_delta import TextDelta -from .tool_request_delta import ToolRequestDelta -from .tool_response_delta import ToolResponseDelta - -__all__ = ["TaskMessageDelta"] - -TaskMessageDelta: TypeAlias = Annotated[ - Union[TextDelta, DataDelta, ToolRequestDelta, ToolResponseDelta], PropertyInfo(discriminator="type") -] diff --git a/src/agentex/types/text_delta.py b/src/agentex/types/text_delta.py deleted file mode 100644 index 29a60cfd..00000000 --- a/src/agentex/types/text_delta.py +++ /dev/null @@ -1,14 +0,0 @@ -# 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__ = ["TextDelta"] - - -class TextDelta(BaseModel): - text_delta: Optional[str] = None - - type: Optional[Literal["text"]] = None diff --git a/src/agentex/types/tool_request_delta.py b/src/agentex/types/tool_request_delta.py deleted file mode 100644 index 7877dfdd..00000000 --- a/src/agentex/types/tool_request_delta.py +++ /dev/null @@ -1,18 +0,0 @@ -# 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__ = ["ToolRequestDelta"] - - -class ToolRequestDelta(BaseModel): - name: str - - tool_call_id: str - - arguments_delta: Optional[str] = None - - type: Optional[Literal["tool_request"]] = None diff --git a/src/agentex/types/tool_response_delta.py b/src/agentex/types/tool_response_delta.py deleted file mode 100644 index 383770db..00000000 --- a/src/agentex/types/tool_response_delta.py +++ /dev/null @@ -1,18 +0,0 @@ -# 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__ = ["ToolResponseDelta"] - - -class ToolResponseDelta(BaseModel): - name: str - - tool_call_id: str - - content_delta: Optional[str] = None - - type: Optional[Literal["tool_response"]] = None diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index 7cb79375..b2819f31 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -9,11 +9,7 @@ from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type -from agentex.types import ( - Agent, - AgentRpcResponse, - AgentListResponse, -) +from agentex.types import Agent, AgentListResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -233,7 +229,7 @@ def test_method_rpc(self, client: Agentex) -> None: method="event/send", params={}, ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -248,7 +244,7 @@ def test_method_rpc_with_all_params(self, client: Agentex) -> None: id=0, jsonrpc="2.0", ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -262,7 +258,7 @@ def test_raw_response_rpc(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -276,7 +272,7 @@ def test_streaming_response_rpc(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -298,7 +294,7 @@ def test_method_rpc_by_name(self, client: Agentex) -> None: method="event/send", params={}, ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -313,7 +309,7 @@ def test_method_rpc_by_name_with_all_params(self, client: Agentex) -> None: id=0, jsonrpc="2.0", ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -327,7 +323,7 @@ def test_raw_response_rpc_by_name(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -341,7 +337,7 @@ def test_streaming_response_rpc_by_name(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -573,7 +569,7 @@ async def test_method_rpc(self, async_client: AsyncAgentex) -> None: method="event/send", params={}, ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -588,7 +584,7 @@ async def test_method_rpc_with_all_params(self, async_client: AsyncAgentex) -> N id=0, jsonrpc="2.0", ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -602,7 +598,7 @@ async def test_raw_response_rpc(self, async_client: AsyncAgentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -616,7 +612,7 @@ async def test_streaming_response_rpc(self, async_client: AsyncAgentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -638,7 +634,7 @@ async def test_method_rpc_by_name(self, async_client: AsyncAgentex) -> None: method="event/send", params={}, ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -653,7 +649,7 @@ async def test_method_rpc_by_name_with_all_params(self, async_client: AsyncAgent id=0, jsonrpc="2.0", ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -667,7 +663,7 @@ async def test_raw_response_rpc_by_name(self, async_client: AsyncAgentex) -> Non assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -681,7 +677,7 @@ async def test_streaming_response_rpc_by_name(self, async_client: AsyncAgentex) assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) assert cast(Any, response.is_closed) is True From 504e02fec0ef16cdbfaf0a6f30f43fcf6d07ebd0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 22 Jul 2025 03:24:44 +0000 Subject: [PATCH 0027/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index f14b480a..aaf968a1 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.1.0-alpha.2" + ".": "0.1.0-alpha.3" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index c45e242b..3ecbcb1c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex" -version = "0.1.0-alpha.2" +version = "0.1.0-alpha.3" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index ac8955e6..90582396 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.1.0-alpha.2" # x-release-please-version +__version__ = "0.1.0-alpha.3" # x-release-please-version From 97345e17f24cc60f23e7d4dc5c8f7ffc5c3ee3b4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 22 Jul 2025 03:30:07 +0000 Subject: [PATCH 0028/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index aaf968a1..b56c3d0b 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.1.0-alpha.3" + ".": "0.1.0-alpha.4" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 3ecbcb1c..9fffbf82 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex" -version = "0.1.0-alpha.3" +version = "0.1.0-alpha.4" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 90582396..756d68b8 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.1.0-alpha.3" # x-release-please-version +__version__ = "0.1.0-alpha.4" # x-release-please-version From 40b2bb6b56c12782525e20adb20523f3f620abc9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 22 Jul 2025 12:04:34 +0000 Subject: [PATCH 0029/1108] fix(parsing): parse extra field types --- src/agentex/_models.py | 25 +++++++++++++++++++++++-- tests/test_models.py | 29 ++++++++++++++++++++++++++++- 2 files changed, 51 insertions(+), 3 deletions(-) diff --git a/src/agentex/_models.py b/src/agentex/_models.py index ffcbf67b..b8387ce9 100644 --- a/src/agentex/_models.py +++ b/src/agentex/_models.py @@ -208,14 +208,18 @@ def construct( # pyright: ignore[reportIncompatibleMethodOverride] else: fields_values[name] = field_get_default(field) + extra_field_type = _get_extra_fields_type(__cls) + _extra = {} for key, value in values.items(): if key not in model_fields: + parsed = construct_type(value=value, type_=extra_field_type) if extra_field_type is not None else value + if PYDANTIC_V2: - _extra[key] = value + _extra[key] = parsed else: _fields_set.add(key) - fields_values[key] = value + fields_values[key] = parsed object.__setattr__(m, "__dict__", fields_values) @@ -370,6 +374,23 @@ def _construct_field(value: object, field: FieldInfo, key: str) -> object: return construct_type(value=value, type_=type_, metadata=getattr(field, "metadata", None)) +def _get_extra_fields_type(cls: type[pydantic.BaseModel]) -> type | None: + if not PYDANTIC_V2: + # TODO + return None + + schema = cls.__pydantic_core_schema__ + if schema["type"] == "model": + fields = schema["schema"] + if fields["type"] == "model-fields": + extras = fields.get("extras_schema") + if extras and "cls" in extras: + # mypy can't narrow the type + return extras["cls"] # type: ignore[no-any-return] + + return None + + def is_basemodel(type_: type) -> bool: """Returns whether or not the given type is either a `BaseModel` or a union of `BaseModel`""" if is_union(type_): diff --git a/tests/test_models.py b/tests/test_models.py index a8867d60..14d98180 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -1,5 +1,5 @@ import json -from typing import Any, Dict, List, Union, Optional, cast +from typing import TYPE_CHECKING, Any, Dict, List, Union, Optional, cast from datetime import datetime, timezone from typing_extensions import Literal, Annotated, TypeAliasType @@ -934,3 +934,30 @@ class Type2(BaseModel): ) assert isinstance(model, Type1) assert isinstance(model.value, InnerType2) + + +@pytest.mark.skipif(not PYDANTIC_V2, reason="this is only supported in pydantic v2 for now") +def test_extra_properties() -> None: + class Item(BaseModel): + prop: int + + class Model(BaseModel): + __pydantic_extra__: Dict[str, Item] = Field(init=False) # pyright: ignore[reportIncompatibleVariableOverride] + + other: str + + if TYPE_CHECKING: + + def __getattr__(self, attr: str) -> Item: ... + + model = construct_type( + type_=Model, + value={ + "a": {"prop": 1}, + "other": "foo", + }, + ) + assert isinstance(model, Model) + assert model.a.prop == 1 + assert isinstance(model.a, Item) + assert model.other == "foo" From 091ca1908b2c1153a285fea00584ebdee53922e1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 22 Jul 2025 16:00:11 +0000 Subject: [PATCH 0030/1108] fix(api): build errors - update openapi spec - comment out models that don't exist - add back methods for backwards compatibility for now --- .stats.yml | 4 +- README.md | 44 +- api.md | 45 +- src/agentex/_client.py | 4 +- src/agentex/resources/agents/__init__.py | 33 ++ src/agentex/resources/{ => agents}/agents.py | 50 +- src/agentex/resources/agents/name.py | 454 ++++++++++++++++++ src/agentex/resources/tasks/__init__.py | 33 ++ src/agentex/resources/tasks/name.py | 324 +++++++++++++ src/agentex/resources/{ => tasks}/tasks.py | 48 +- src/agentex/types/agents/__init__.py | 6 + .../types/agents/name_handle_rpc_params.py | 85 ++++ src/agentex/types/agents/name_rpc_params.py | 85 ++++ src/agentex/types/tasks/__init__.py | 3 + tests/api_resources/agents/__init__.py | 1 + tests/api_resources/agents/test_name.py | 452 +++++++++++++++++ tests/api_resources/tasks/__init__.py | 1 + tests/api_resources/tasks/test_name.py | 274 +++++++++++ tests/conftest.py | 8 +- tests/test_client.py | 227 ++++++--- 20 files changed, 2044 insertions(+), 137 deletions(-) create mode 100644 src/agentex/resources/agents/__init__.py rename src/agentex/resources/{ => agents}/agents.py (94%) create mode 100644 src/agentex/resources/agents/name.py create mode 100644 src/agentex/resources/tasks/__init__.py create mode 100644 src/agentex/resources/tasks/name.py rename src/agentex/resources/{ => tasks}/tasks.py (94%) create mode 100644 src/agentex/types/agents/__init__.py create mode 100644 src/agentex/types/agents/name_handle_rpc_params.py create mode 100644 src/agentex/types/agents/name_rpc_params.py create mode 100644 src/agentex/types/tasks/__init__.py create mode 100644 tests/api_resources/agents/__init__.py create mode 100644 tests/api_resources/agents/test_name.py create mode 100644 tests/api_resources/tasks/__init__.py create mode 100644 tests/api_resources/tasks/test_name.py diff --git a/.stats.yml b/.stats.yml index 91523e16..5a7503fb 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-021b55c88964b7a5bfc9d692d32a52c6b0150445656d2407c4cb8e9dd1e5f100.yml -openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 -config_hash: 7661726e3cccf9f6349179841153601d +openapi_spec_hash: 3f634d45f6241dea4fbdac496b70f5a3 +config_hash: 7c45df33d1cc4df7ea9dac3b0968b0f0 diff --git a/README.md b/README.md index 2bdbb592..588fc8cc 100644 --- a/README.md +++ b/README.md @@ -28,17 +28,16 @@ pip install git+ssh://git@github.com/scaleapi/agentex-python.git The full API of this library can be found in [api.md](api.md). ```python +import os from agentex import Agentex client = Agentex( + api_key=os.environ.get("AGENTEX_SDK_API_KEY"), # This is the default and can be omitted # defaults to "production". environment="development", ) -agent = client.agents.retrieve( - "agent_id", -) -print(agent.id) +tasks = client.tasks.list() ``` While you can provide an `api_key` keyword argument, @@ -51,20 +50,19 @@ so that your API Key is not stored in source control. Simply import `AsyncAgentex` instead of `Agentex` and use `await` with each API call: ```python +import os import asyncio from agentex import AsyncAgentex client = AsyncAgentex( + api_key=os.environ.get("AGENTEX_SDK_API_KEY"), # This is the default and can be omitted # defaults to "production". environment="development", ) async def main() -> None: - agent = await client.agents.retrieve( - "agent_id", - ) - print(agent.id) + tasks = await client.tasks.list() asyncio.run(main()) @@ -93,12 +91,10 @@ from agentex import AsyncAgentex async def main() -> None: async with AsyncAgentex( + api_key="My API Key", http_client=DefaultAioHttpClient(), ) as client: - agent = await client.agents.retrieve( - "agent_id", - ) - print(agent.id) + tasks = await client.tasks.list() asyncio.run(main()) @@ -129,9 +125,7 @@ from agentex import Agentex client = Agentex() try: - client.agents.retrieve( - "agent_id", - ) + client.tasks.list() except agentex.APIConnectionError as e: print("The server could not be reached") print(e.__cause__) # an underlying Exception, likely raised within httpx. @@ -174,9 +168,7 @@ client = Agentex( ) # Or, configure per-request: -client.with_options(max_retries=5).agents.retrieve( - "agent_id", -) +client.with_options(max_retries=5).tasks.list() ``` ### Timeouts @@ -199,9 +191,7 @@ client = Agentex( ) # Override per-request: -client.with_options(timeout=5.0).agents.retrieve( - "agent_id", -) +client.with_options(timeout=5.0).tasks.list() ``` On timeout, an `APITimeoutError` is thrown. @@ -242,13 +232,11 @@ The "raw" Response object can be accessed by prefixing `.with_raw_response.` to from agentex import Agentex client = Agentex() -response = client.agents.with_raw_response.retrieve( - "agent_id", -) +response = client.tasks.with_raw_response.list() print(response.headers.get('X-My-Header')) -agent = response.parse() # get the object that `agents.retrieve()` would have returned -print(agent.id) +task = response.parse() # get the object that `tasks.list()` would have returned +print(task) ``` These methods return an [`APIResponse`](https://github.com/scaleapi/agentex-python/tree/main/src/agentex/_response.py) object. @@ -262,9 +250,7 @@ The above interface eagerly reads the full response body when you make the reque To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods. ```python -with client.agents.with_streaming_response.retrieve( - "agent_id", -) as response: +with client.tasks.with_streaming_response.list() as response: print(response.headers.get("X-My-Header")) for line in response.iter_lines(): diff --git a/api.md b/api.md index 8c2841ca..0d482fb9 100644 --- a/api.md +++ b/api.md @@ -8,13 +8,22 @@ from agentex.types import AcpType, Agent, AgentRpcRequest, AgentListResponse Methods: -- client.agents.retrieve(agent_id) -> Agent -- client.agents.list(\*\*params) -> AgentListResponse -- client.agents.delete(agent_id) -> Agent -- client.agents.delete_by_name(agent_name) -> Agent -- client.agents.retrieve_by_name(agent_name) -> Agent -- client.agents.rpc(agent_id, \*\*params) -> object -- client.agents.rpc_by_name(agent_name, \*\*params) -> object +- client.agents.retrieve(agent_id) -> Agent +- client.agents.list(\*\*params) -> AgentListResponse +- client.agents.delete(agent_id) -> Agent +- client.agents.delete_by_name(agent_name) -> Agent +- client.agents.retrieve_by_name(agent_name) -> Agent +- client.agents.rpc(agent_id, \*\*params) -> object +- client.agents.rpc_by_name(agent_name, \*\*params) -> object + +## Name + +Methods: + +- client.agents.name.retrieve(agent_name) -> Agent +- client.agents.name.delete(agent_name) -> Agent +- client.agents.name.handle_rpc(agent_name, \*\*params) -> object +- client.agents.name.rpc(agent_name, \*\*params) -> object # Tasks @@ -26,13 +35,21 @@ from agentex.types import Task, TaskListResponse Methods: -- client.tasks.retrieve(task_id) -> Task -- client.tasks.list() -> TaskListResponse -- client.tasks.delete(task_id) -> Task -- client.tasks.delete_by_name(task_name) -> Task -- client.tasks.retrieve_by_name(task_name) -> Task -- client.tasks.stream_events(task_id) -> object -- client.tasks.stream_events_by_name(task_name) -> object +- client.tasks.retrieve(task_id) -> Task +- client.tasks.list() -> TaskListResponse +- client.tasks.delete(task_id) -> Task +- client.tasks.delete_by_name(task_name) -> Task +- client.tasks.retrieve_by_name(task_name) -> Task +- client.tasks.stream_events(task_id) -> object +- client.tasks.stream_events_by_name(task_name) -> object + +## Name + +Methods: + +- client.tasks.name.retrieve(task_name) -> Task +- client.tasks.name.delete(task_name) -> Task +- client.tasks.name.stream_events(task_name) -> object # Messages diff --git a/src/agentex/_client.py b/src/agentex/_client.py index 51ebb5e8..d1af575d 100644 --- a/src/agentex/_client.py +++ b/src/agentex/_client.py @@ -21,7 +21,7 @@ ) from ._utils import is_given, get_async_library from ._version import __version__ -from .resources import spans, tasks, agents, events, states, tracker +from .resources import spans, events, states, tracker from ._streaming import Stream as Stream, AsyncStream as AsyncStream from ._exceptions import APIStatusError from ._base_client import ( @@ -29,6 +29,8 @@ SyncAPIClient, AsyncAPIClient, ) +from .resources.tasks import tasks +from .resources.agents import agents from .resources.messages import messages __all__ = [ diff --git a/src/agentex/resources/agents/__init__.py b/src/agentex/resources/agents/__init__.py new file mode 100644 index 00000000..374345e0 --- /dev/null +++ b/src/agentex/resources/agents/__init__.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .name import ( + NameResource, + AsyncNameResource, + NameResourceWithRawResponse, + AsyncNameResourceWithRawResponse, + NameResourceWithStreamingResponse, + AsyncNameResourceWithStreamingResponse, +) +from .agents import ( + AgentsResource, + AsyncAgentsResource, + AgentsResourceWithRawResponse, + AsyncAgentsResourceWithRawResponse, + AgentsResourceWithStreamingResponse, + AsyncAgentsResourceWithStreamingResponse, +) + +__all__ = [ + "NameResource", + "AsyncNameResource", + "NameResourceWithRawResponse", + "AsyncNameResourceWithRawResponse", + "NameResourceWithStreamingResponse", + "AsyncNameResourceWithStreamingResponse", + "AgentsResource", + "AsyncAgentsResource", + "AgentsResourceWithRawResponse", + "AsyncAgentsResourceWithRawResponse", + "AgentsResourceWithStreamingResponse", + "AsyncAgentsResourceWithStreamingResponse", +] diff --git a/src/agentex/resources/agents.py b/src/agentex/resources/agents/agents.py similarity index 94% rename from src/agentex/resources/agents.py rename to src/agentex/resources/agents/agents.py index 9c2e4bd5..cdd3b891 100644 --- a/src/agentex/resources/agents.py +++ b/src/agentex/resources/agents/agents.py @@ -7,25 +7,37 @@ import httpx -from ..types import agent_rpc_params, agent_list_params, agent_rpc_by_name_params -from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from .._utils import maybe_transform, async_maybe_transform -from .._compat import cached_property -from .._resource import SyncAPIResource, AsyncAPIResource -from .._response import ( +from .name import ( + NameResource, + AsyncNameResource, + NameResourceWithRawResponse, + AsyncNameResourceWithRawResponse, + NameResourceWithStreamingResponse, + AsyncNameResourceWithStreamingResponse, +) +from ...types import agent_rpc_params, agent_list_params, agent_rpc_by_name_params +from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._utils import maybe_transform, async_maybe_transform +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( to_raw_response_wrapper, to_streamed_response_wrapper, async_to_raw_response_wrapper, async_to_streamed_response_wrapper, ) -from ..types.agent import Agent -from .._base_client import make_request_options -from ..types.agent_list_response import AgentListResponse +from ...types.agent import Agent +from ..._base_client import make_request_options +from ...types.agent_list_response import AgentListResponse __all__ = ["AgentsResource", "AsyncAgentsResource"] class AgentsResource(SyncAPIResource): + @cached_property + def name(self) -> NameResource: + return NameResource(self._client) + @cached_property def with_raw_response(self) -> AgentsResourceWithRawResponse: """ @@ -308,6 +320,10 @@ def rpc_by_name( class AsyncAgentsResource(AsyncAPIResource): + @cached_property + def name(self) -> AsyncNameResource: + return AsyncNameResource(self._client) + @cached_property def with_raw_response(self) -> AsyncAgentsResourceWithRawResponse: """ @@ -615,6 +631,10 @@ def __init__(self, agents: AgentsResource) -> None: agents.rpc_by_name, ) + @cached_property + def name(self) -> NameResourceWithRawResponse: + return NameResourceWithRawResponse(self._agents.name) + class AsyncAgentsResourceWithRawResponse: def __init__(self, agents: AsyncAgentsResource) -> None: @@ -642,6 +662,10 @@ def __init__(self, agents: AsyncAgentsResource) -> None: agents.rpc_by_name, ) + @cached_property + def name(self) -> AsyncNameResourceWithRawResponse: + return AsyncNameResourceWithRawResponse(self._agents.name) + class AgentsResourceWithStreamingResponse: def __init__(self, agents: AgentsResource) -> None: @@ -669,6 +693,10 @@ def __init__(self, agents: AgentsResource) -> None: agents.rpc_by_name, ) + @cached_property + def name(self) -> NameResourceWithStreamingResponse: + return NameResourceWithStreamingResponse(self._agents.name) + class AsyncAgentsResourceWithStreamingResponse: def __init__(self, agents: AsyncAgentsResource) -> None: @@ -695,3 +723,7 @@ def __init__(self, agents: AsyncAgentsResource) -> None: self.rpc_by_name = async_to_streamed_response_wrapper( agents.rpc_by_name, ) + + @cached_property + def name(self) -> AsyncNameResourceWithStreamingResponse: + return AsyncNameResourceWithStreamingResponse(self._agents.name) diff --git a/src/agentex/resources/agents/name.py b/src/agentex/resources/agents/name.py new file mode 100644 index 00000000..fd8c82f9 --- /dev/null +++ b/src/agentex/resources/agents/name.py @@ -0,0 +1,454 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union +from typing_extensions import Literal + +import httpx + +from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._utils import maybe_transform, async_maybe_transform +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ...types.agent import Agent +from ..._base_client import make_request_options +from ...types.agents import name_rpc_params, name_handle_rpc_params + +__all__ = ["NameResource", "AsyncNameResource"] + + +class NameResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> NameResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + """ + return NameResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> NameResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + """ + return NameResourceWithStreamingResponse(self) + + def retrieve( + self, + agent_name: str, + *, + # 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, + ) -> Agent: + """ + Get an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return self._get( + f"/agents/name/{agent_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + def delete( + self, + agent_name: str, + *, + # 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, + ) -> Agent: + """ + Delete an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return self._delete( + f"/agents/name/{agent_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + def handle_rpc( + self, + agent_name: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: name_handle_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> object: + """ + Handle JSON-RPC requests for an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return self._post( + f"/agents/name/{agent_name}/rpc", + body=maybe_transform( + { + "method": method, + "params": params, + "id": id, + "jsonrpc": jsonrpc, + }, + name_handle_rpc_params.NameHandleRpcParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + ) + + def rpc( + self, + agent_name: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: name_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> object: + """ + Handle JSON-RPC requests for an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return self._post( + f"/agents/name/{agent_name}/rpc", + body=maybe_transform( + { + "method": method, + "params": params, + "id": id, + "jsonrpc": jsonrpc, + }, + name_rpc_params.NameRpcParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + ) + + +class AsyncNameResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncNameResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + """ + return AsyncNameResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncNameResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + """ + return AsyncNameResourceWithStreamingResponse(self) + + async def retrieve( + self, + agent_name: str, + *, + # 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, + ) -> Agent: + """ + Get an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return await self._get( + f"/agents/name/{agent_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + async def delete( + self, + agent_name: str, + *, + # 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, + ) -> Agent: + """ + Delete an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return await self._delete( + f"/agents/name/{agent_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Agent, + ) + + async def handle_rpc( + self, + agent_name: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: name_handle_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> object: + """ + Handle JSON-RPC requests for an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return await self._post( + f"/agents/name/{agent_name}/rpc", + body=await async_maybe_transform( + { + "method": method, + "params": params, + "id": id, + "jsonrpc": jsonrpc, + }, + name_handle_rpc_params.NameHandleRpcParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + ) + + async def rpc( + self, + agent_name: str, + *, + method: Literal["event/send", "task/create", "message/send", "task/cancel"], + params: name_rpc_params.Params, + id: Union[int, str, None] | NotGiven = NOT_GIVEN, + jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + # 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, + ) -> object: + """ + Handle JSON-RPC requests for an agent by its unique name. + + Args: + 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 + """ + if not agent_name: + raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") + return await self._post( + f"/agents/name/{agent_name}/rpc", + body=await async_maybe_transform( + { + "method": method, + "params": params, + "id": id, + "jsonrpc": jsonrpc, + }, + name_rpc_params.NameRpcParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + ) + + +class NameResourceWithRawResponse: + def __init__(self, name: NameResource) -> None: + self._name = name + + self.retrieve = to_raw_response_wrapper( + name.retrieve, + ) + self.delete = to_raw_response_wrapper( + name.delete, + ) + self.handle_rpc = to_raw_response_wrapper( + name.handle_rpc, + ) + self.rpc = to_raw_response_wrapper( + name.rpc, + ) + + +class AsyncNameResourceWithRawResponse: + def __init__(self, name: AsyncNameResource) -> None: + self._name = name + + self.retrieve = async_to_raw_response_wrapper( + name.retrieve, + ) + self.delete = async_to_raw_response_wrapper( + name.delete, + ) + self.handle_rpc = async_to_raw_response_wrapper( + name.handle_rpc, + ) + self.rpc = async_to_raw_response_wrapper( + name.rpc, + ) + + +class NameResourceWithStreamingResponse: + def __init__(self, name: NameResource) -> None: + self._name = name + + self.retrieve = to_streamed_response_wrapper( + name.retrieve, + ) + self.delete = to_streamed_response_wrapper( + name.delete, + ) + self.handle_rpc = to_streamed_response_wrapper( + name.handle_rpc, + ) + self.rpc = to_streamed_response_wrapper( + name.rpc, + ) + + +class AsyncNameResourceWithStreamingResponse: + def __init__(self, name: AsyncNameResource) -> None: + self._name = name + + self.retrieve = async_to_streamed_response_wrapper( + name.retrieve, + ) + self.delete = async_to_streamed_response_wrapper( + name.delete, + ) + self.handle_rpc = async_to_streamed_response_wrapper( + name.handle_rpc, + ) + self.rpc = async_to_streamed_response_wrapper( + name.rpc, + ) diff --git a/src/agentex/resources/tasks/__init__.py b/src/agentex/resources/tasks/__init__.py new file mode 100644 index 00000000..5a9c81b0 --- /dev/null +++ b/src/agentex/resources/tasks/__init__.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .name import ( + NameResource, + AsyncNameResource, + NameResourceWithRawResponse, + AsyncNameResourceWithRawResponse, + NameResourceWithStreamingResponse, + AsyncNameResourceWithStreamingResponse, +) +from .tasks import ( + TasksResource, + AsyncTasksResource, + TasksResourceWithRawResponse, + AsyncTasksResourceWithRawResponse, + TasksResourceWithStreamingResponse, + AsyncTasksResourceWithStreamingResponse, +) + +__all__ = [ + "NameResource", + "AsyncNameResource", + "NameResourceWithRawResponse", + "AsyncNameResourceWithRawResponse", + "NameResourceWithStreamingResponse", + "AsyncNameResourceWithStreamingResponse", + "TasksResource", + "AsyncTasksResource", + "TasksResourceWithRawResponse", + "AsyncTasksResourceWithRawResponse", + "TasksResourceWithStreamingResponse", + "AsyncTasksResourceWithStreamingResponse", +] diff --git a/src/agentex/resources/tasks/name.py b/src/agentex/resources/tasks/name.py new file mode 100644 index 00000000..7cef42eb --- /dev/null +++ b/src/agentex/resources/tasks/name.py @@ -0,0 +1,324 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import httpx + +from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ..._streaming import Stream, AsyncStream +from ...types.task import Task +from ..._base_client import make_request_options + +__all__ = ["NameResource", "AsyncNameResource"] + + +class NameResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> NameResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + """ + return NameResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> NameResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + """ + return NameResourceWithStreamingResponse(self) + + def retrieve( + self, + task_name: str, + *, + # 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, + ) -> Task: + """ + Get a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return self._get( + f"/tasks/name/{task_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + + def delete( + self, + task_name: str, + *, + # 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, + ) -> Task: + """ + Delete a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return self._delete( + f"/tasks/name/{task_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + + def stream_events( + self, + task_name: str, + *, + # 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, + ) -> Stream[object]: + """ + Stream events for a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return self._get( + f"/tasks/name/{task_name}/stream", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + stream=True, + stream_cls=Stream[object], + ) + + +class AsyncNameResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncNameResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + """ + return AsyncNameResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncNameResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + """ + return AsyncNameResourceWithStreamingResponse(self) + + async def retrieve( + self, + task_name: str, + *, + # 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, + ) -> Task: + """ + Get a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return await self._get( + f"/tasks/name/{task_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + + async def delete( + self, + task_name: str, + *, + # 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, + ) -> Task: + """ + Delete a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return await self._delete( + f"/tasks/name/{task_name}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Task, + ) + + async def stream_events( + self, + task_name: str, + *, + # 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, + ) -> AsyncStream[object]: + """ + Stream events for a task by its unique name. + + Args: + 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 + """ + if not task_name: + raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") + return await self._get( + f"/tasks/name/{task_name}/stream", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + stream=True, + stream_cls=AsyncStream[object], + ) + + +class NameResourceWithRawResponse: + def __init__(self, name: NameResource) -> None: + self._name = name + + self.retrieve = to_raw_response_wrapper( + name.retrieve, + ) + self.delete = to_raw_response_wrapper( + name.delete, + ) + self.stream_events = to_raw_response_wrapper( + name.stream_events, + ) + + +class AsyncNameResourceWithRawResponse: + def __init__(self, name: AsyncNameResource) -> None: + self._name = name + + self.retrieve = async_to_raw_response_wrapper( + name.retrieve, + ) + self.delete = async_to_raw_response_wrapper( + name.delete, + ) + self.stream_events = async_to_raw_response_wrapper( + name.stream_events, + ) + + +class NameResourceWithStreamingResponse: + def __init__(self, name: NameResource) -> None: + self._name = name + + self.retrieve = to_streamed_response_wrapper( + name.retrieve, + ) + self.delete = to_streamed_response_wrapper( + name.delete, + ) + self.stream_events = to_streamed_response_wrapper( + name.stream_events, + ) + + +class AsyncNameResourceWithStreamingResponse: + def __init__(self, name: AsyncNameResource) -> None: + self._name = name + + self.retrieve = async_to_streamed_response_wrapper( + name.retrieve, + ) + self.delete = async_to_streamed_response_wrapper( + name.delete, + ) + self.stream_events = async_to_streamed_response_wrapper( + name.stream_events, + ) diff --git a/src/agentex/resources/tasks.py b/src/agentex/resources/tasks/tasks.py similarity index 94% rename from src/agentex/resources/tasks.py rename to src/agentex/resources/tasks/tasks.py index 936ee66c..ce1a7813 100644 --- a/src/agentex/resources/tasks.py +++ b/src/agentex/resources/tasks/tasks.py @@ -4,24 +4,36 @@ import httpx -from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from .._compat import cached_property -from .._resource import SyncAPIResource, AsyncAPIResource -from .._response import ( +from .name import ( + NameResource, + AsyncNameResource, + NameResourceWithRawResponse, + AsyncNameResourceWithRawResponse, + NameResourceWithStreamingResponse, + AsyncNameResourceWithStreamingResponse, +) +from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( to_raw_response_wrapper, to_streamed_response_wrapper, async_to_raw_response_wrapper, async_to_streamed_response_wrapper, ) -from .._streaming import Stream, AsyncStream -from ..types.task import Task -from .._base_client import make_request_options -from ..types.task_list_response import TaskListResponse +from ..._streaming import Stream, AsyncStream +from ...types.task import Task +from ..._base_client import make_request_options +from ...types.task_list_response import TaskListResponse __all__ = ["TasksResource", "AsyncTasksResource"] class TasksResource(SyncAPIResource): + @cached_property + def name(self) -> NameResource: + return NameResource(self._client) + @cached_property def with_raw_response(self) -> TasksResourceWithRawResponse: """ @@ -264,6 +276,10 @@ def stream_events_by_name( class AsyncTasksResource(AsyncAPIResource): + @cached_property + def name(self) -> AsyncNameResource: + return AsyncNameResource(self._client) + @cached_property def with_raw_response(self) -> AsyncTasksResourceWithRawResponse: """ @@ -531,6 +547,10 @@ def __init__(self, tasks: TasksResource) -> None: tasks.stream_events_by_name, ) + @cached_property + def name(self) -> NameResourceWithRawResponse: + return NameResourceWithRawResponse(self._tasks.name) + class AsyncTasksResourceWithRawResponse: def __init__(self, tasks: AsyncTasksResource) -> None: @@ -558,6 +578,10 @@ def __init__(self, tasks: AsyncTasksResource) -> None: tasks.stream_events_by_name, ) + @cached_property + def name(self) -> AsyncNameResourceWithRawResponse: + return AsyncNameResourceWithRawResponse(self._tasks.name) + class TasksResourceWithStreamingResponse: def __init__(self, tasks: TasksResource) -> None: @@ -585,6 +609,10 @@ def __init__(self, tasks: TasksResource) -> None: tasks.stream_events_by_name, ) + @cached_property + def name(self) -> NameResourceWithStreamingResponse: + return NameResourceWithStreamingResponse(self._tasks.name) + class AsyncTasksResourceWithStreamingResponse: def __init__(self, tasks: AsyncTasksResource) -> None: @@ -611,3 +639,7 @@ def __init__(self, tasks: AsyncTasksResource) -> None: self.stream_events_by_name = async_to_streamed_response_wrapper( tasks.stream_events_by_name, ) + + @cached_property + def name(self) -> AsyncNameResourceWithStreamingResponse: + return AsyncNameResourceWithStreamingResponse(self._tasks.name) diff --git a/src/agentex/types/agents/__init__.py b/src/agentex/types/agents/__init__.py new file mode 100644 index 00000000..6211202a --- /dev/null +++ b/src/agentex/types/agents/__init__.py @@ -0,0 +1,6 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from .name_rpc_params import NameRpcParams as NameRpcParams +from .name_handle_rpc_params import NameHandleRpcParams as NameHandleRpcParams diff --git a/src/agentex/types/agents/name_handle_rpc_params.py b/src/agentex/types/agents/name_handle_rpc_params.py new file mode 100644 index 00000000..d1d903a6 --- /dev/null +++ b/src/agentex/types/agents/name_handle_rpc_params.py @@ -0,0 +1,85 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict, Union, Optional +from typing_extensions import Literal, Required, TypeAlias, TypedDict + +from ..data_content_param import DataContentParam +from ..text_content_param import TextContentParam +from ..tool_request_content_param import ToolRequestContentParam +from ..tool_response_content_param import ToolResponseContentParam + +__all__ = [ + "NameHandleRpcParams", + "Params", + "ParamsCreateTaskRequest", + "ParamsCancelTaskRequest", + "ParamsSendMessageRequest", + "ParamsSendMessageRequestContent", + "ParamsSendEventRequest", + "ParamsSendEventRequestContent", +] + + +class NameHandleRpcParams(TypedDict, total=False): + method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] + + params: Required[Params] + + id: Union[int, str, None] + + jsonrpc: Literal["2.0"] + + +class ParamsCreateTaskRequest(TypedDict, total=False): + name: Optional[str] + """The name of the task to create""" + + params: Optional[Dict[str, object]] + """The parameters for the task""" + + +class ParamsCancelTaskRequest(TypedDict, total=False): + task_id: Optional[str] + """The ID of the task to cancel. Either this or task_name must be provided.""" + + task_name: Optional[str] + """The name of the task to cancel. Either this or task_id must be provided.""" + + +ParamsSendMessageRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendMessageRequest(TypedDict, total=False): + content: Required[ParamsSendMessageRequestContent] + """The message that was sent to the agent""" + + stream: bool + """Whether to stream the response message back to the client""" + + task_id: Optional[str] + """The ID of the task that the message was sent to""" + + +ParamsSendEventRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendEventRequest(TypedDict, total=False): + content: Optional[ParamsSendEventRequestContent] + """The content to send to the event""" + + task_id: Optional[str] + """The ID of the task that the event was sent to""" + + task_name: Optional[str] + """The name of the task that the event was sent to""" + + +Params: TypeAlias = Union[ + ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest +] diff --git a/src/agentex/types/agents/name_rpc_params.py b/src/agentex/types/agents/name_rpc_params.py new file mode 100644 index 00000000..6a68b0ba --- /dev/null +++ b/src/agentex/types/agents/name_rpc_params.py @@ -0,0 +1,85 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict, Union, Optional +from typing_extensions import Literal, Required, TypeAlias, TypedDict + +from ..data_content_param import DataContentParam +from ..text_content_param import TextContentParam +from ..tool_request_content_param import ToolRequestContentParam +from ..tool_response_content_param import ToolResponseContentParam + +__all__ = [ + "NameRpcParams", + "Params", + "ParamsCreateTaskRequest", + "ParamsCancelTaskRequest", + "ParamsSendMessageRequest", + "ParamsSendMessageRequestContent", + "ParamsSendEventRequest", + "ParamsSendEventRequestContent", +] + + +class NameRpcParams(TypedDict, total=False): + method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] + + params: Required[Params] + + id: Union[int, str, None] + + jsonrpc: Literal["2.0"] + + +class ParamsCreateTaskRequest(TypedDict, total=False): + name: Optional[str] + """The name of the task to create""" + + params: Optional[Dict[str, object]] + """The parameters for the task""" + + +class ParamsCancelTaskRequest(TypedDict, total=False): + task_id: Optional[str] + """The ID of the task to cancel. Either this or task_name must be provided.""" + + task_name: Optional[str] + """The name of the task to cancel. Either this or task_id must be provided.""" + + +ParamsSendMessageRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendMessageRequest(TypedDict, total=False): + content: Required[ParamsSendMessageRequestContent] + """The message that was sent to the agent""" + + stream: bool + """Whether to stream the response message back to the client""" + + task_id: Optional[str] + """The ID of the task that the message was sent to""" + + +ParamsSendEventRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendEventRequest(TypedDict, total=False): + content: Optional[ParamsSendEventRequestContent] + """The content to send to the event""" + + task_id: Optional[str] + """The ID of the task that the event was sent to""" + + task_name: Optional[str] + """The name of the task that the event was sent to""" + + +Params: TypeAlias = Union[ + ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest +] diff --git a/src/agentex/types/tasks/__init__.py b/src/agentex/types/tasks/__init__.py new file mode 100644 index 00000000..f8ee8b14 --- /dev/null +++ b/src/agentex/types/tasks/__init__.py @@ -0,0 +1,3 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations diff --git a/tests/api_resources/agents/__init__.py b/tests/api_resources/agents/__init__.py new file mode 100644 index 00000000..fd8019a9 --- /dev/null +++ b/tests/api_resources/agents/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/agents/test_name.py b/tests/api_resources/agents/test_name.py new file mode 100644 index 00000000..dea82f12 --- /dev/null +++ b/tests/api_resources/agents/test_name.py @@ -0,0 +1,452 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from agentex import Agentex, AsyncAgentex +from tests.utils import assert_matches_type +from agentex.types import Agent + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestName: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + def test_method_retrieve(self, client: Agentex) -> None: + name = client.agents.name.retrieve( + "agent_name", + ) + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_retrieve(self, client: Agentex) -> None: + response = client.agents.name.with_raw_response.retrieve( + "agent_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = response.parse() + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_retrieve(self, client: Agentex) -> None: + with client.agents.name.with_streaming_response.retrieve( + "agent_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = response.parse() + assert_matches_type(Agent, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_retrieve(self, client: Agentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + client.agents.name.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_delete(self, client: Agentex) -> None: + name = client.agents.name.delete( + "agent_name", + ) + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_delete(self, client: Agentex) -> None: + response = client.agents.name.with_raw_response.delete( + "agent_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = response.parse() + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_delete(self, client: Agentex) -> None: + with client.agents.name.with_streaming_response.delete( + "agent_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = response.parse() + assert_matches_type(Agent, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_delete(self, client: Agentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + client.agents.name.with_raw_response.delete( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_handle_rpc(self, client: Agentex) -> None: + name = client.agents.name.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + assert_matches_type(object, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_handle_rpc_with_all_params(self, client: Agentex) -> None: + name = client.agents.name.handle_rpc( + agent_name="agent_name", + method="event/send", + params={ + "name": "name", + "params": {"foo": "bar"}, + }, + id=0, + jsonrpc="2.0", + ) + assert_matches_type(object, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_handle_rpc(self, client: Agentex) -> None: + response = client.agents.name.with_raw_response.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = response.parse() + assert_matches_type(object, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_handle_rpc(self, client: Agentex) -> None: + with client.agents.name.with_streaming_response.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = response.parse() + assert_matches_type(object, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_handle_rpc(self, client: Agentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + client.agents.name.with_raw_response.handle_rpc( + agent_name="", + method="event/send", + params={}, + ) + + @pytest.mark.skip() + @parametrize + def test_method_rpc(self, client: Agentex) -> None: + name = client.agents.name.rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + assert_matches_type(object, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_rpc_with_all_params(self, client: Agentex) -> None: + name = client.agents.name.rpc( + agent_name="agent_name", + method="event/send", + params={ + "name": "name", + "params": {"foo": "bar"}, + }, + id=0, + jsonrpc="2.0", + ) + assert_matches_type(object, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_rpc(self, client: Agentex) -> None: + response = client.agents.name.with_raw_response.rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = response.parse() + assert_matches_type(object, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_rpc(self, client: Agentex) -> None: + with client.agents.name.with_streaming_response.rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = response.parse() + assert_matches_type(object, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_rpc(self, client: Agentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + client.agents.name.with_raw_response.rpc( + agent_name="", + method="event/send", + params={}, + ) + + +class TestAsyncName: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip() + @parametrize + async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: + name = await async_client.agents.name.retrieve( + "agent_name", + ) + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: + response = await async_client.agents.name.with_raw_response.retrieve( + "agent_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = await response.parse() + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: + async with async_client.agents.name.with_streaming_response.retrieve( + "agent_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = await response.parse() + assert_matches_type(Agent, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + await async_client.agents.name.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_delete(self, async_client: AsyncAgentex) -> None: + name = await async_client.agents.name.delete( + "agent_name", + ) + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: + response = await async_client.agents.name.with_raw_response.delete( + "agent_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = await response.parse() + assert_matches_type(Agent, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> None: + async with async_client.agents.name.with_streaming_response.delete( + "agent_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = await response.parse() + assert_matches_type(Agent, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + await async_client.agents.name.with_raw_response.delete( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_handle_rpc(self, async_client: AsyncAgentex) -> None: + name = await async_client.agents.name.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + assert_matches_type(object, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_handle_rpc_with_all_params(self, async_client: AsyncAgentex) -> None: + name = await async_client.agents.name.handle_rpc( + agent_name="agent_name", + method="event/send", + params={ + "name": "name", + "params": {"foo": "bar"}, + }, + id=0, + jsonrpc="2.0", + ) + assert_matches_type(object, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_handle_rpc(self, async_client: AsyncAgentex) -> None: + response = await async_client.agents.name.with_raw_response.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = await response.parse() + assert_matches_type(object, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_handle_rpc(self, async_client: AsyncAgentex) -> None: + async with async_client.agents.name.with_streaming_response.handle_rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = await response.parse() + assert_matches_type(object, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_handle_rpc(self, async_client: AsyncAgentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + await async_client.agents.name.with_raw_response.handle_rpc( + agent_name="", + method="event/send", + params={}, + ) + + @pytest.mark.skip() + @parametrize + async def test_method_rpc(self, async_client: AsyncAgentex) -> None: + name = await async_client.agents.name.rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + assert_matches_type(object, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_rpc_with_all_params(self, async_client: AsyncAgentex) -> None: + name = await async_client.agents.name.rpc( + agent_name="agent_name", + method="event/send", + params={ + "name": "name", + "params": {"foo": "bar"}, + }, + id=0, + jsonrpc="2.0", + ) + assert_matches_type(object, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_rpc(self, async_client: AsyncAgentex) -> None: + response = await async_client.agents.name.with_raw_response.rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = await response.parse() + assert_matches_type(object, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_rpc(self, async_client: AsyncAgentex) -> None: + async with async_client.agents.name.with_streaming_response.rpc( + agent_name="agent_name", + method="event/send", + params={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = await response.parse() + assert_matches_type(object, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_rpc(self, async_client: AsyncAgentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): + await async_client.agents.name.with_raw_response.rpc( + agent_name="", + method="event/send", + params={}, + ) diff --git a/tests/api_resources/tasks/__init__.py b/tests/api_resources/tasks/__init__.py new file mode 100644 index 00000000..fd8019a9 --- /dev/null +++ b/tests/api_resources/tasks/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/tasks/test_name.py b/tests/api_resources/tasks/test_name.py new file mode 100644 index 00000000..cb000659 --- /dev/null +++ b/tests/api_resources/tasks/test_name.py @@ -0,0 +1,274 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from agentex import Agentex, AsyncAgentex +from tests.utils import assert_matches_type +from agentex.types import Task + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestName: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + def test_method_retrieve(self, client: Agentex) -> None: + name = client.tasks.name.retrieve( + "task_name", + ) + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_retrieve(self, client: Agentex) -> None: + response = client.tasks.name.with_raw_response.retrieve( + "task_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = response.parse() + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_retrieve(self, client: Agentex) -> None: + with client.tasks.name.with_streaming_response.retrieve( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = response.parse() + assert_matches_type(Task, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_retrieve(self, client: Agentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + client.tasks.name.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_delete(self, client: Agentex) -> None: + name = client.tasks.name.delete( + "task_name", + ) + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_delete(self, client: Agentex) -> None: + response = client.tasks.name.with_raw_response.delete( + "task_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = response.parse() + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_delete(self, client: Agentex) -> None: + with client.tasks.name.with_streaming_response.delete( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = response.parse() + assert_matches_type(Task, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_delete(self, client: Agentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + client.tasks.name.with_raw_response.delete( + "", + ) + + @pytest.mark.skip() + @parametrize + def test_method_stream_events(self, client: Agentex) -> None: + name_stream = client.tasks.name.stream_events( + "task_name", + ) + name_stream.response.close() + + @pytest.mark.skip() + @parametrize + def test_raw_response_stream_events(self, client: Agentex) -> None: + response = client.tasks.name.with_raw_response.stream_events( + "task_name", + ) + + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + stream = response.parse() + stream.close() + + @pytest.mark.skip() + @parametrize + def test_streaming_response_stream_events(self, client: Agentex) -> None: + with client.tasks.name.with_streaming_response.stream_events( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + stream = response.parse() + stream.close() + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_path_params_stream_events(self, client: Agentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + client.tasks.name.with_raw_response.stream_events( + "", + ) + + +class TestAsyncName: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip() + @parametrize + async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: + name = await async_client.tasks.name.retrieve( + "task_name", + ) + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: + response = await async_client.tasks.name.with_raw_response.retrieve( + "task_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = await response.parse() + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: + async with async_client.tasks.name.with_streaming_response.retrieve( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = await response.parse() + assert_matches_type(Task, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + await async_client.tasks.name.with_raw_response.retrieve( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_delete(self, async_client: AsyncAgentex) -> None: + name = await async_client.tasks.name.delete( + "task_name", + ) + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: + response = await async_client.tasks.name.with_raw_response.delete( + "task_name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + name = await response.parse() + assert_matches_type(Task, name, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> None: + async with async_client.tasks.name.with_streaming_response.delete( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + name = await response.parse() + assert_matches_type(Task, name, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + await async_client.tasks.name.with_raw_response.delete( + "", + ) + + @pytest.mark.skip() + @parametrize + async def test_method_stream_events(self, async_client: AsyncAgentex) -> None: + name_stream = await async_client.tasks.name.stream_events( + "task_name", + ) + await name_stream.response.aclose() + + @pytest.mark.skip() + @parametrize + async def test_raw_response_stream_events(self, async_client: AsyncAgentex) -> None: + response = await async_client.tasks.name.with_raw_response.stream_events( + "task_name", + ) + + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + stream = await response.parse() + await stream.close() + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_stream_events(self, async_client: AsyncAgentex) -> None: + async with async_client.tasks.name.with_streaming_response.stream_events( + "task_name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + stream = await response.parse() + await stream.close() + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_path_params_stream_events(self, async_client: AsyncAgentex) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): + await async_client.tasks.name.with_raw_response.stream_events( + "", + ) diff --git a/tests/conftest.py b/tests/conftest.py index b6e6697e..d08e65cf 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -45,6 +45,8 @@ def pytest_collection_modifyitems(items: list[pytest.Function]) -> None: base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") +api_key = "My API Key" + @pytest.fixture(scope="session") def client(request: FixtureRequest) -> Iterator[Agentex]: @@ -52,7 +54,7 @@ def client(request: FixtureRequest) -> Iterator[Agentex]: if not isinstance(strict, bool): raise TypeError(f"Unexpected fixture parameter type {type(strict)}, expected {bool}") - with Agentex(base_url=base_url, _strict_response_validation=strict) as client: + with Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=strict) as client: yield client @@ -76,5 +78,7 @@ async def async_client(request: FixtureRequest) -> AsyncIterator[AsyncAgentex]: else: raise TypeError(f"Unexpected fixture parameter type {type(param)}, expected bool or dict") - async with AsyncAgentex(base_url=base_url, _strict_response_validation=strict, http_client=http_client) as client: + async with AsyncAgentex( + base_url=base_url, api_key=api_key, _strict_response_validation=strict, http_client=http_client + ) as client: yield client diff --git a/tests/test_client.py b/tests/test_client.py index 2fe22ed9..da5399da 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -37,6 +37,7 @@ from .utils import update_env base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") +api_key = "My API Key" def _get_params(client: BaseClient[Any, Any]) -> dict[str, str]: @@ -58,7 +59,7 @@ def _get_open_connections(client: Agentex | AsyncAgentex) -> int: class TestAgentex: - client = Agentex(base_url=base_url, _strict_response_validation=True) + client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) @pytest.mark.respx(base_url=base_url) def test_raw_response(self, respx_mock: MockRouter) -> None: @@ -84,6 +85,10 @@ def test_copy(self) -> None: copied = self.client.copy() assert id(copied) != id(self.client) + copied = self.client.copy(api_key="another My API Key") + assert copied.api_key == "another My API Key" + assert self.client.api_key == "My API Key" + def test_copy_default_options(self) -> None: # options that have a default are overridden correctly copied = self.client.copy(max_retries=7) @@ -101,7 +106,9 @@ def test_copy_default_options(self) -> None: assert isinstance(self.client.timeout, httpx.Timeout) def test_copy_default_headers(self) -> None: - client = Agentex(base_url=base_url, _strict_response_validation=True, default_headers={"X-Foo": "bar"}) + client = Agentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} + ) assert client.default_headers["X-Foo"] == "bar" # does not override the already given value when not specified @@ -133,7 +140,9 @@ def test_copy_default_headers(self) -> None: client.copy(set_default_headers={}, default_headers={"X-Foo": "Bar"}) def test_copy_default_query(self) -> None: - client = Agentex(base_url=base_url, _strict_response_validation=True, default_query={"foo": "bar"}) + client = Agentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"foo": "bar"} + ) assert _get_params(client)["foo"] == "bar" # does not override the already given value when not specified @@ -257,7 +266,7 @@ def test_request_timeout(self) -> None: assert timeout == httpx.Timeout(100.0) def test_client_timeout_option(self) -> None: - client = Agentex(base_url=base_url, _strict_response_validation=True, timeout=httpx.Timeout(0)) + client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True, timeout=httpx.Timeout(0)) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -266,7 +275,9 @@ def test_client_timeout_option(self) -> None: def test_http_client_timeout_option(self) -> None: # custom timeout given to the httpx client should be used with httpx.Client(timeout=None) as http_client: - client = Agentex(base_url=base_url, _strict_response_validation=True, http_client=http_client) + client = Agentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client + ) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -274,7 +285,9 @@ def test_http_client_timeout_option(self) -> None: # no timeout given to the httpx client should not use the httpx default with httpx.Client() as http_client: - client = Agentex(base_url=base_url, _strict_response_validation=True, http_client=http_client) + client = Agentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client + ) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -282,7 +295,9 @@ def test_http_client_timeout_option(self) -> None: # explicitly passing the default timeout currently results in it being ignored with httpx.Client(timeout=HTTPX_DEFAULT_TIMEOUT) as http_client: - client = Agentex(base_url=base_url, _strict_response_validation=True, http_client=http_client) + client = Agentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client + ) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -291,16 +306,24 @@ def test_http_client_timeout_option(self) -> None: async def test_invalid_http_client(self) -> None: with pytest.raises(TypeError, match="Invalid `http_client` arg"): async with httpx.AsyncClient() as http_client: - Agentex(base_url=base_url, _strict_response_validation=True, http_client=cast(Any, http_client)) + Agentex( + base_url=base_url, + api_key=api_key, + _strict_response_validation=True, + http_client=cast(Any, http_client), + ) def test_default_headers_option(self) -> None: - client = Agentex(base_url=base_url, _strict_response_validation=True, default_headers={"X-Foo": "bar"}) + client = Agentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} + ) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) assert request.headers.get("x-foo") == "bar" assert request.headers.get("x-stainless-lang") == "python" client2 = Agentex( base_url=base_url, + api_key=api_key, _strict_response_validation=True, default_headers={ "X-Foo": "stainless", @@ -311,8 +334,20 @@ def test_default_headers_option(self) -> None: assert request.headers.get("x-foo") == "stainless" assert request.headers.get("x-stainless-lang") == "my-overriding-header" + def test_validate_headers(self) -> None: + client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + assert request.headers.get("Authorization") == f"Bearer {api_key}" + + with update_env(**{"AGENTEX_SDK_API_KEY": Omit()}): + client2 = Agentex(base_url=base_url, api_key=None, _strict_response_validation=True) + + client2._build_request(FinalRequestOptions(method="get", url="/foo")) + def test_default_query_option(self) -> None: - client = Agentex(base_url=base_url, _strict_response_validation=True, default_query={"query_param": "bar"}) + client = Agentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"query_param": "bar"} + ) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) url = httpx.URL(request.url) assert dict(url.params) == {"query_param": "bar"} @@ -511,7 +546,7 @@ class Model(BaseModel): assert response.foo == 2 def test_base_url_setter(self) -> None: - client = Agentex(base_url="https://example.com/from_init", _strict_response_validation=True) + client = Agentex(base_url="https://example.com/from_init", api_key=api_key, _strict_response_validation=True) assert client.base_url == "https://example.com/from_init/" client.base_url = "https://example.com/from_setter" # type: ignore[assignment] @@ -520,23 +555,24 @@ def test_base_url_setter(self) -> None: def test_base_url_env(self) -> None: with update_env(AGENTEX_BASE_URL="http://localhost:5000/from/env"): - client = Agentex(_strict_response_validation=True) + client = Agentex(api_key=api_key, _strict_response_validation=True) assert client.base_url == "http://localhost:5000/from/env/" # explicit environment arg requires explicitness with update_env(AGENTEX_BASE_URL="http://localhost:5000/from/env"): with pytest.raises(ValueError, match=r"you must pass base_url=None"): - Agentex(_strict_response_validation=True, environment="production") + Agentex(api_key=api_key, _strict_response_validation=True, environment="production") - client = Agentex(base_url=None, _strict_response_validation=True, environment="production") + client = Agentex(base_url=None, api_key=api_key, _strict_response_validation=True, environment="production") assert str(client.base_url).startswith("http://localhost:5003") @pytest.mark.parametrize( "client", [ - Agentex(base_url="http://localhost:5000/custom/path/", _strict_response_validation=True), + Agentex(base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True), Agentex( base_url="http://localhost:5000/custom/path/", + api_key=api_key, _strict_response_validation=True, http_client=httpx.Client(), ), @@ -556,9 +592,10 @@ def test_base_url_trailing_slash(self, client: Agentex) -> None: @pytest.mark.parametrize( "client", [ - Agentex(base_url="http://localhost:5000/custom/path/", _strict_response_validation=True), + Agentex(base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True), Agentex( base_url="http://localhost:5000/custom/path/", + api_key=api_key, _strict_response_validation=True, http_client=httpx.Client(), ), @@ -578,9 +615,10 @@ def test_base_url_no_trailing_slash(self, client: Agentex) -> None: @pytest.mark.parametrize( "client", [ - Agentex(base_url="http://localhost:5000/custom/path/", _strict_response_validation=True), + Agentex(base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True), Agentex( base_url="http://localhost:5000/custom/path/", + api_key=api_key, _strict_response_validation=True, http_client=httpx.Client(), ), @@ -598,7 +636,7 @@ def test_absolute_request_url(self, client: Agentex) -> None: assert request.url == "https://myapi.com/foo" def test_copied_client_does_not_close_http(self) -> None: - client = Agentex(base_url=base_url, _strict_response_validation=True) + client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) assert not client.is_closed() copied = client.copy() @@ -609,7 +647,7 @@ def test_copied_client_does_not_close_http(self) -> None: assert not client.is_closed() def test_client_context_manager(self) -> None: - client = Agentex(base_url=base_url, _strict_response_validation=True) + client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) with client as c2: assert c2 is client assert not c2.is_closed() @@ -630,7 +668,7 @@ class Model(BaseModel): def test_client_max_retries_validation(self) -> None: with pytest.raises(TypeError, match=r"max_retries cannot be None"): - Agentex(base_url=base_url, _strict_response_validation=True, max_retries=cast(Any, None)) + Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True, max_retries=cast(Any, None)) @pytest.mark.respx(base_url=base_url) def test_received_text_for_expected_json(self, respx_mock: MockRouter) -> None: @@ -639,12 +677,12 @@ class Model(BaseModel): respx_mock.get("/foo").mock(return_value=httpx.Response(200, text="my-custom-format")) - strict_client = Agentex(base_url=base_url, _strict_response_validation=True) + strict_client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) with pytest.raises(APIResponseValidationError): strict_client.get("/foo", cast_to=Model) - client = Agentex(base_url=base_url, _strict_response_validation=False) + client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=False) response = client.get("/foo", cast_to=Model) assert isinstance(response, str) # type: ignore[unreachable] @@ -672,7 +710,7 @@ class Model(BaseModel): ) @mock.patch("time.time", mock.MagicMock(return_value=1696004797)) def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str, timeout: float) -> None: - client = Agentex(base_url=base_url, _strict_response_validation=True) + client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) headers = httpx.Headers({"retry-after": retry_after}) options = FinalRequestOptions(method="get", url="/foo", max_retries=3) @@ -682,20 +720,20 @@ def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter, client: Agentex) -> None: - respx_mock.get("/agents/agent_id").mock(side_effect=httpx.TimeoutException("Test timeout error")) + respx_mock.get("/tasks").mock(side_effect=httpx.TimeoutException("Test timeout error")) with pytest.raises(APITimeoutError): - client.agents.with_streaming_response.retrieve("agent_id").__enter__() + client.tasks.with_streaming_response.list().__enter__() assert _get_open_connections(self.client) == 0 @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, client: Agentex) -> None: - respx_mock.get("/agents/agent_id").mock(return_value=httpx.Response(500)) + respx_mock.get("/tasks").mock(return_value=httpx.Response(500)) with pytest.raises(APIStatusError): - client.agents.with_streaming_response.retrieve("agent_id").__enter__() + client.tasks.with_streaming_response.list().__enter__() assert _get_open_connections(self.client) == 0 @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) @@ -722,9 +760,9 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: return httpx.Response(500) return httpx.Response(200) - respx_mock.get("/agents/agent_id").mock(side_effect=retry_handler) + respx_mock.get("/tasks").mock(side_effect=retry_handler) - response = client.agents.with_raw_response.retrieve("agent_id") + response = client.tasks.with_raw_response.list() assert response.retries_taken == failures_before_success assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success @@ -746,11 +784,9 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: return httpx.Response(500) return httpx.Response(200) - respx_mock.get("/agents/agent_id").mock(side_effect=retry_handler) + respx_mock.get("/tasks").mock(side_effect=retry_handler) - response = client.agents.with_raw_response.retrieve( - "agent_id", extra_headers={"x-stainless-retry-count": Omit()} - ) + response = client.tasks.with_raw_response.list(extra_headers={"x-stainless-retry-count": Omit()}) assert len(response.http_request.headers.get_list("x-stainless-retry-count")) == 0 @@ -771,9 +807,9 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: return httpx.Response(500) return httpx.Response(200) - respx_mock.get("/agents/agent_id").mock(side_effect=retry_handler) + respx_mock.get("/tasks").mock(side_effect=retry_handler) - response = client.agents.with_raw_response.retrieve("agent_id", extra_headers={"x-stainless-retry-count": "42"}) + response = client.tasks.with_raw_response.list(extra_headers={"x-stainless-retry-count": "42"}) assert response.http_request.headers.get("x-stainless-retry-count") == "42" @@ -828,7 +864,7 @@ def test_follow_redirects_disabled(self, respx_mock: MockRouter) -> None: class TestAsyncAgentex: - client = AsyncAgentex(base_url=base_url, _strict_response_validation=True) + client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) @pytest.mark.respx(base_url=base_url) @pytest.mark.asyncio @@ -856,6 +892,10 @@ def test_copy(self) -> None: copied = self.client.copy() assert id(copied) != id(self.client) + copied = self.client.copy(api_key="another My API Key") + assert copied.api_key == "another My API Key" + assert self.client.api_key == "My API Key" + def test_copy_default_options(self) -> None: # options that have a default are overridden correctly copied = self.client.copy(max_retries=7) @@ -873,7 +913,9 @@ def test_copy_default_options(self) -> None: assert isinstance(self.client.timeout, httpx.Timeout) def test_copy_default_headers(self) -> None: - client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, default_headers={"X-Foo": "bar"}) + client = AsyncAgentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} + ) assert client.default_headers["X-Foo"] == "bar" # does not override the already given value when not specified @@ -905,7 +947,9 @@ def test_copy_default_headers(self) -> None: client.copy(set_default_headers={}, default_headers={"X-Foo": "Bar"}) def test_copy_default_query(self) -> None: - client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, default_query={"foo": "bar"}) + client = AsyncAgentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"foo": "bar"} + ) assert _get_params(client)["foo"] == "bar" # does not override the already given value when not specified @@ -1029,7 +1073,9 @@ async def test_request_timeout(self) -> None: assert timeout == httpx.Timeout(100.0) async def test_client_timeout_option(self) -> None: - client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, timeout=httpx.Timeout(0)) + client = AsyncAgentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, timeout=httpx.Timeout(0) + ) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -1038,7 +1084,9 @@ async def test_client_timeout_option(self) -> None: async def test_http_client_timeout_option(self) -> None: # custom timeout given to the httpx client should be used async with httpx.AsyncClient(timeout=None) as http_client: - client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, http_client=http_client) + client = AsyncAgentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client + ) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -1046,7 +1094,9 @@ async def test_http_client_timeout_option(self) -> None: # no timeout given to the httpx client should not use the httpx default async with httpx.AsyncClient() as http_client: - client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, http_client=http_client) + client = AsyncAgentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client + ) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -1054,7 +1104,9 @@ async def test_http_client_timeout_option(self) -> None: # explicitly passing the default timeout currently results in it being ignored async with httpx.AsyncClient(timeout=HTTPX_DEFAULT_TIMEOUT) as http_client: - client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, http_client=http_client) + client = AsyncAgentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, http_client=http_client + ) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -1063,16 +1115,24 @@ async def test_http_client_timeout_option(self) -> None: def test_invalid_http_client(self) -> None: with pytest.raises(TypeError, match="Invalid `http_client` arg"): with httpx.Client() as http_client: - AsyncAgentex(base_url=base_url, _strict_response_validation=True, http_client=cast(Any, http_client)) + AsyncAgentex( + base_url=base_url, + api_key=api_key, + _strict_response_validation=True, + http_client=cast(Any, http_client), + ) def test_default_headers_option(self) -> None: - client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, default_headers={"X-Foo": "bar"}) + client = AsyncAgentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} + ) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) assert request.headers.get("x-foo") == "bar" assert request.headers.get("x-stainless-lang") == "python" client2 = AsyncAgentex( base_url=base_url, + api_key=api_key, _strict_response_validation=True, default_headers={ "X-Foo": "stainless", @@ -1083,8 +1143,20 @@ def test_default_headers_option(self) -> None: assert request.headers.get("x-foo") == "stainless" assert request.headers.get("x-stainless-lang") == "my-overriding-header" + def test_validate_headers(self) -> None: + client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + assert request.headers.get("Authorization") == f"Bearer {api_key}" + + with update_env(**{"AGENTEX_SDK_API_KEY": Omit()}): + client2 = AsyncAgentex(base_url=base_url, api_key=None, _strict_response_validation=True) + + client2._build_request(FinalRequestOptions(method="get", url="/foo")) + def test_default_query_option(self) -> None: - client = AsyncAgentex(base_url=base_url, _strict_response_validation=True, default_query={"query_param": "bar"}) + client = AsyncAgentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"query_param": "bar"} + ) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) url = httpx.URL(request.url) assert dict(url.params) == {"query_param": "bar"} @@ -1283,7 +1355,9 @@ class Model(BaseModel): assert response.foo == 2 def test_base_url_setter(self) -> None: - client = AsyncAgentex(base_url="https://example.com/from_init", _strict_response_validation=True) + client = AsyncAgentex( + base_url="https://example.com/from_init", api_key=api_key, _strict_response_validation=True + ) assert client.base_url == "https://example.com/from_init/" client.base_url = "https://example.com/from_setter" # type: ignore[assignment] @@ -1292,23 +1366,28 @@ def test_base_url_setter(self) -> None: def test_base_url_env(self) -> None: with update_env(AGENTEX_BASE_URL="http://localhost:5000/from/env"): - client = AsyncAgentex(_strict_response_validation=True) + client = AsyncAgentex(api_key=api_key, _strict_response_validation=True) assert client.base_url == "http://localhost:5000/from/env/" # explicit environment arg requires explicitness with update_env(AGENTEX_BASE_URL="http://localhost:5000/from/env"): with pytest.raises(ValueError, match=r"you must pass base_url=None"): - AsyncAgentex(_strict_response_validation=True, environment="production") + AsyncAgentex(api_key=api_key, _strict_response_validation=True, environment="production") - client = AsyncAgentex(base_url=None, _strict_response_validation=True, environment="production") + client = AsyncAgentex( + base_url=None, api_key=api_key, _strict_response_validation=True, environment="production" + ) assert str(client.base_url).startswith("http://localhost:5003") @pytest.mark.parametrize( "client", [ - AsyncAgentex(base_url="http://localhost:5000/custom/path/", _strict_response_validation=True), + AsyncAgentex( + base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True + ), AsyncAgentex( base_url="http://localhost:5000/custom/path/", + api_key=api_key, _strict_response_validation=True, http_client=httpx.AsyncClient(), ), @@ -1328,9 +1407,12 @@ def test_base_url_trailing_slash(self, client: AsyncAgentex) -> None: @pytest.mark.parametrize( "client", [ - AsyncAgentex(base_url="http://localhost:5000/custom/path/", _strict_response_validation=True), + AsyncAgentex( + base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True + ), AsyncAgentex( base_url="http://localhost:5000/custom/path/", + api_key=api_key, _strict_response_validation=True, http_client=httpx.AsyncClient(), ), @@ -1350,9 +1432,12 @@ def test_base_url_no_trailing_slash(self, client: AsyncAgentex) -> None: @pytest.mark.parametrize( "client", [ - AsyncAgentex(base_url="http://localhost:5000/custom/path/", _strict_response_validation=True), + AsyncAgentex( + base_url="http://localhost:5000/custom/path/", api_key=api_key, _strict_response_validation=True + ), AsyncAgentex( base_url="http://localhost:5000/custom/path/", + api_key=api_key, _strict_response_validation=True, http_client=httpx.AsyncClient(), ), @@ -1370,7 +1455,7 @@ def test_absolute_request_url(self, client: AsyncAgentex) -> None: assert request.url == "https://myapi.com/foo" async def test_copied_client_does_not_close_http(self) -> None: - client = AsyncAgentex(base_url=base_url, _strict_response_validation=True) + client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) assert not client.is_closed() copied = client.copy() @@ -1382,7 +1467,7 @@ async def test_copied_client_does_not_close_http(self) -> None: assert not client.is_closed() async def test_client_context_manager(self) -> None: - client = AsyncAgentex(base_url=base_url, _strict_response_validation=True) + client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) async with client as c2: assert c2 is client assert not c2.is_closed() @@ -1404,7 +1489,9 @@ class Model(BaseModel): async def test_client_max_retries_validation(self) -> None: with pytest.raises(TypeError, match=r"max_retries cannot be None"): - AsyncAgentex(base_url=base_url, _strict_response_validation=True, max_retries=cast(Any, None)) + AsyncAgentex( + base_url=base_url, api_key=api_key, _strict_response_validation=True, max_retries=cast(Any, None) + ) @pytest.mark.respx(base_url=base_url) @pytest.mark.asyncio @@ -1414,12 +1501,12 @@ class Model(BaseModel): respx_mock.get("/foo").mock(return_value=httpx.Response(200, text="my-custom-format")) - strict_client = AsyncAgentex(base_url=base_url, _strict_response_validation=True) + strict_client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) with pytest.raises(APIResponseValidationError): await strict_client.get("/foo", cast_to=Model) - client = AsyncAgentex(base_url=base_url, _strict_response_validation=False) + client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=False) response = await client.get("/foo", cast_to=Model) assert isinstance(response, str) # type: ignore[unreachable] @@ -1448,7 +1535,7 @@ class Model(BaseModel): @mock.patch("time.time", mock.MagicMock(return_value=1696004797)) @pytest.mark.asyncio async def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str, timeout: float) -> None: - client = AsyncAgentex(base_url=base_url, _strict_response_validation=True) + client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) headers = httpx.Headers({"retry-after": retry_after}) options = FinalRequestOptions(method="get", url="/foo", max_retries=3) @@ -1460,20 +1547,20 @@ async def test_parse_retry_after_header(self, remaining_retries: int, retry_afte async def test_retrying_timeout_errors_doesnt_leak( self, respx_mock: MockRouter, async_client: AsyncAgentex ) -> None: - respx_mock.get("/agents/agent_id").mock(side_effect=httpx.TimeoutException("Test timeout error")) + respx_mock.get("/tasks").mock(side_effect=httpx.TimeoutException("Test timeout error")) with pytest.raises(APITimeoutError): - await async_client.agents.with_streaming_response.retrieve("agent_id").__aenter__() + await async_client.tasks.with_streaming_response.list().__aenter__() assert _get_open_connections(self.client) == 0 @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) async def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, async_client: AsyncAgentex) -> None: - respx_mock.get("/agents/agent_id").mock(return_value=httpx.Response(500)) + respx_mock.get("/tasks").mock(return_value=httpx.Response(500)) with pytest.raises(APIStatusError): - await async_client.agents.with_streaming_response.retrieve("agent_id").__aenter__() + await async_client.tasks.with_streaming_response.list().__aenter__() assert _get_open_connections(self.client) == 0 @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) @@ -1501,9 +1588,9 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: return httpx.Response(500) return httpx.Response(200) - respx_mock.get("/agents/agent_id").mock(side_effect=retry_handler) + respx_mock.get("/tasks").mock(side_effect=retry_handler) - response = await client.agents.with_raw_response.retrieve("agent_id") + response = await client.tasks.with_raw_response.list() assert response.retries_taken == failures_before_success assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success @@ -1526,11 +1613,9 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: return httpx.Response(500) return httpx.Response(200) - respx_mock.get("/agents/agent_id").mock(side_effect=retry_handler) + respx_mock.get("/tasks").mock(side_effect=retry_handler) - response = await client.agents.with_raw_response.retrieve( - "agent_id", extra_headers={"x-stainless-retry-count": Omit()} - ) + response = await client.tasks.with_raw_response.list(extra_headers={"x-stainless-retry-count": Omit()}) assert len(response.http_request.headers.get_list("x-stainless-retry-count")) == 0 @@ -1552,11 +1637,9 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: return httpx.Response(500) return httpx.Response(200) - respx_mock.get("/agents/agent_id").mock(side_effect=retry_handler) + respx_mock.get("/tasks").mock(side_effect=retry_handler) - response = await client.agents.with_raw_response.retrieve( - "agent_id", extra_headers={"x-stainless-retry-count": "42"} - ) + response = await client.tasks.with_raw_response.list(extra_headers={"x-stainless-retry-count": "42"}) assert response.http_request.headers.get("x-stainless-retry-count") == "42" From 63cb58e473a6945c2c11836e608ff97470ee8f29 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 22 Jul 2025 16:23:50 +0000 Subject: [PATCH 0031/1108] codegen metadata --- .stats.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.stats.yml b/.stats.yml index 5a7503fb..48c29b8d 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-021b55c88964b7a5bfc9d692d32a52c6b0150445656d2407c4cb8e9dd1e5f100.yml -openapi_spec_hash: 3f634d45f6241dea4fbdac496b70f5a3 +openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 config_hash: 7c45df33d1cc4df7ea9dac3b0968b0f0 From 26b3a8258ff44e82bd66f0181309eda5412b4750 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 22 Jul 2025 16:59:44 +0000 Subject: [PATCH 0032/1108] feat(api): deprecate name subresource --- .stats.yml | 2 +- api.md | 45 +- src/agentex/_client.py | 4 +- src/agentex/resources/{agents => }/agents.py | 50 +- src/agentex/resources/agents/__init__.py | 33 -- src/agentex/resources/agents/name.py | 454 ------------------ src/agentex/resources/{tasks => }/tasks.py | 48 +- src/agentex/resources/tasks/__init__.py | 33 -- src/agentex/resources/tasks/name.py | 324 ------------- src/agentex/types/agents/__init__.py | 6 - .../types/agents/name_handle_rpc_params.py | 85 ---- src/agentex/types/agents/name_rpc_params.py | 85 ---- src/agentex/types/tasks/__init__.py | 3 - tests/api_resources/agents/__init__.py | 1 - tests/api_resources/agents/test_name.py | 452 ----------------- tests/api_resources/tasks/__init__.py | 1 - tests/api_resources/tasks/test_name.py | 274 ----------- 17 files changed, 33 insertions(+), 1867 deletions(-) rename src/agentex/resources/{agents => }/agents.py (94%) delete mode 100644 src/agentex/resources/agents/__init__.py delete mode 100644 src/agentex/resources/agents/name.py rename src/agentex/resources/{tasks => }/tasks.py (94%) delete mode 100644 src/agentex/resources/tasks/__init__.py delete mode 100644 src/agentex/resources/tasks/name.py delete mode 100644 src/agentex/types/agents/__init__.py delete mode 100644 src/agentex/types/agents/name_handle_rpc_params.py delete mode 100644 src/agentex/types/agents/name_rpc_params.py delete mode 100644 src/agentex/types/tasks/__init__.py delete mode 100644 tests/api_resources/agents/__init__.py delete mode 100644 tests/api_resources/agents/test_name.py delete mode 100644 tests/api_resources/tasks/__init__.py delete mode 100644 tests/api_resources/tasks/test_name.py diff --git a/.stats.yml b/.stats.yml index 48c29b8d..a111f762 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-021b55c88964b7a5bfc9d692d32a52c6b0150445656d2407c4cb8e9dd1e5f100.yml openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 -config_hash: 7c45df33d1cc4df7ea9dac3b0968b0f0 +config_hash: 5a41a91d658dffbd60d617eb02e945f6 diff --git a/api.md b/api.md index 0d482fb9..8c2841ca 100644 --- a/api.md +++ b/api.md @@ -8,22 +8,13 @@ from agentex.types import AcpType, Agent, AgentRpcRequest, AgentListResponse Methods: -- client.agents.retrieve(agent_id) -> Agent -- client.agents.list(\*\*params) -> AgentListResponse -- client.agents.delete(agent_id) -> Agent -- client.agents.delete_by_name(agent_name) -> Agent -- client.agents.retrieve_by_name(agent_name) -> Agent -- client.agents.rpc(agent_id, \*\*params) -> object -- client.agents.rpc_by_name(agent_name, \*\*params) -> object - -## Name - -Methods: - -- client.agents.name.retrieve(agent_name) -> Agent -- client.agents.name.delete(agent_name) -> Agent -- client.agents.name.handle_rpc(agent_name, \*\*params) -> object -- client.agents.name.rpc(agent_name, \*\*params) -> object +- client.agents.retrieve(agent_id) -> Agent +- client.agents.list(\*\*params) -> AgentListResponse +- client.agents.delete(agent_id) -> Agent +- client.agents.delete_by_name(agent_name) -> Agent +- client.agents.retrieve_by_name(agent_name) -> Agent +- client.agents.rpc(agent_id, \*\*params) -> object +- client.agents.rpc_by_name(agent_name, \*\*params) -> object # Tasks @@ -35,21 +26,13 @@ from agentex.types import Task, TaskListResponse Methods: -- client.tasks.retrieve(task_id) -> Task -- client.tasks.list() -> TaskListResponse -- client.tasks.delete(task_id) -> Task -- client.tasks.delete_by_name(task_name) -> Task -- client.tasks.retrieve_by_name(task_name) -> Task -- client.tasks.stream_events(task_id) -> object -- client.tasks.stream_events_by_name(task_name) -> object - -## Name - -Methods: - -- client.tasks.name.retrieve(task_name) -> Task -- client.tasks.name.delete(task_name) -> Task -- client.tasks.name.stream_events(task_name) -> object +- client.tasks.retrieve(task_id) -> Task +- client.tasks.list() -> TaskListResponse +- client.tasks.delete(task_id) -> Task +- client.tasks.delete_by_name(task_name) -> Task +- client.tasks.retrieve_by_name(task_name) -> Task +- client.tasks.stream_events(task_id) -> object +- client.tasks.stream_events_by_name(task_name) -> object # Messages diff --git a/src/agentex/_client.py b/src/agentex/_client.py index d1af575d..51ebb5e8 100644 --- a/src/agentex/_client.py +++ b/src/agentex/_client.py @@ -21,7 +21,7 @@ ) from ._utils import is_given, get_async_library from ._version import __version__ -from .resources import spans, events, states, tracker +from .resources import spans, tasks, agents, events, states, tracker from ._streaming import Stream as Stream, AsyncStream as AsyncStream from ._exceptions import APIStatusError from ._base_client import ( @@ -29,8 +29,6 @@ SyncAPIClient, AsyncAPIClient, ) -from .resources.tasks import tasks -from .resources.agents import agents from .resources.messages import messages __all__ = [ diff --git a/src/agentex/resources/agents/agents.py b/src/agentex/resources/agents.py similarity index 94% rename from src/agentex/resources/agents/agents.py rename to src/agentex/resources/agents.py index cdd3b891..9c2e4bd5 100644 --- a/src/agentex/resources/agents/agents.py +++ b/src/agentex/resources/agents.py @@ -7,37 +7,25 @@ import httpx -from .name import ( - NameResource, - AsyncNameResource, - NameResourceWithRawResponse, - AsyncNameResourceWithRawResponse, - NameResourceWithStreamingResponse, - AsyncNameResourceWithStreamingResponse, -) -from ...types import agent_rpc_params, agent_list_params, agent_rpc_by_name_params -from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from ..._utils import maybe_transform, async_maybe_transform -from ..._compat import cached_property -from ..._resource import SyncAPIResource, AsyncAPIResource -from ..._response import ( +from ..types import agent_rpc_params, agent_list_params, agent_rpc_by_name_params +from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._utils import maybe_transform, async_maybe_transform +from .._compat import cached_property +from .._resource import SyncAPIResource, AsyncAPIResource +from .._response import ( to_raw_response_wrapper, to_streamed_response_wrapper, async_to_raw_response_wrapper, async_to_streamed_response_wrapper, ) -from ...types.agent import Agent -from ..._base_client import make_request_options -from ...types.agent_list_response import AgentListResponse +from ..types.agent import Agent +from .._base_client import make_request_options +from ..types.agent_list_response import AgentListResponse __all__ = ["AgentsResource", "AsyncAgentsResource"] class AgentsResource(SyncAPIResource): - @cached_property - def name(self) -> NameResource: - return NameResource(self._client) - @cached_property def with_raw_response(self) -> AgentsResourceWithRawResponse: """ @@ -320,10 +308,6 @@ def rpc_by_name( class AsyncAgentsResource(AsyncAPIResource): - @cached_property - def name(self) -> AsyncNameResource: - return AsyncNameResource(self._client) - @cached_property def with_raw_response(self) -> AsyncAgentsResourceWithRawResponse: """ @@ -631,10 +615,6 @@ def __init__(self, agents: AgentsResource) -> None: agents.rpc_by_name, ) - @cached_property - def name(self) -> NameResourceWithRawResponse: - return NameResourceWithRawResponse(self._agents.name) - class AsyncAgentsResourceWithRawResponse: def __init__(self, agents: AsyncAgentsResource) -> None: @@ -662,10 +642,6 @@ def __init__(self, agents: AsyncAgentsResource) -> None: agents.rpc_by_name, ) - @cached_property - def name(self) -> AsyncNameResourceWithRawResponse: - return AsyncNameResourceWithRawResponse(self._agents.name) - class AgentsResourceWithStreamingResponse: def __init__(self, agents: AgentsResource) -> None: @@ -693,10 +669,6 @@ def __init__(self, agents: AgentsResource) -> None: agents.rpc_by_name, ) - @cached_property - def name(self) -> NameResourceWithStreamingResponse: - return NameResourceWithStreamingResponse(self._agents.name) - class AsyncAgentsResourceWithStreamingResponse: def __init__(self, agents: AsyncAgentsResource) -> None: @@ -723,7 +695,3 @@ def __init__(self, agents: AsyncAgentsResource) -> None: self.rpc_by_name = async_to_streamed_response_wrapper( agents.rpc_by_name, ) - - @cached_property - def name(self) -> AsyncNameResourceWithStreamingResponse: - return AsyncNameResourceWithStreamingResponse(self._agents.name) diff --git a/src/agentex/resources/agents/__init__.py b/src/agentex/resources/agents/__init__.py deleted file mode 100644 index 374345e0..00000000 --- a/src/agentex/resources/agents/__init__.py +++ /dev/null @@ -1,33 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .name import ( - NameResource, - AsyncNameResource, - NameResourceWithRawResponse, - AsyncNameResourceWithRawResponse, - NameResourceWithStreamingResponse, - AsyncNameResourceWithStreamingResponse, -) -from .agents import ( - AgentsResource, - AsyncAgentsResource, - AgentsResourceWithRawResponse, - AsyncAgentsResourceWithRawResponse, - AgentsResourceWithStreamingResponse, - AsyncAgentsResourceWithStreamingResponse, -) - -__all__ = [ - "NameResource", - "AsyncNameResource", - "NameResourceWithRawResponse", - "AsyncNameResourceWithRawResponse", - "NameResourceWithStreamingResponse", - "AsyncNameResourceWithStreamingResponse", - "AgentsResource", - "AsyncAgentsResource", - "AgentsResourceWithRawResponse", - "AsyncAgentsResourceWithRawResponse", - "AgentsResourceWithStreamingResponse", - "AsyncAgentsResourceWithStreamingResponse", -] diff --git a/src/agentex/resources/agents/name.py b/src/agentex/resources/agents/name.py deleted file mode 100644 index fd8c82f9..00000000 --- a/src/agentex/resources/agents/name.py +++ /dev/null @@ -1,454 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Union -from typing_extensions import Literal - -import httpx - -from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from ..._utils import maybe_transform, async_maybe_transform -from ..._compat import cached_property -from ..._resource import SyncAPIResource, AsyncAPIResource -from ..._response import ( - to_raw_response_wrapper, - to_streamed_response_wrapper, - async_to_raw_response_wrapper, - async_to_streamed_response_wrapper, -) -from ...types.agent import Agent -from ..._base_client import make_request_options -from ...types.agents import name_rpc_params, name_handle_rpc_params - -__all__ = ["NameResource", "AsyncNameResource"] - - -class NameResource(SyncAPIResource): - @cached_property - def with_raw_response(self) -> NameResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers - """ - return NameResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> NameResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response - """ - return NameResourceWithStreamingResponse(self) - - def retrieve( - self, - agent_name: str, - *, - # 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, - ) -> Agent: - """ - Get an agent by its unique name. - - Args: - 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 - """ - if not agent_name: - raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") - return self._get( - f"/agents/name/{agent_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Agent, - ) - - def delete( - self, - agent_name: str, - *, - # 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, - ) -> Agent: - """ - Delete an agent by its unique name. - - Args: - 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 - """ - if not agent_name: - raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") - return self._delete( - f"/agents/name/{agent_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Agent, - ) - - def handle_rpc( - self, - agent_name: str, - *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: name_handle_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, - # 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, - ) -> object: - """ - Handle JSON-RPC requests for an agent by its unique name. - - Args: - 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 - """ - if not agent_name: - raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") - return self._post( - f"/agents/name/{agent_name}/rpc", - body=maybe_transform( - { - "method": method, - "params": params, - "id": id, - "jsonrpc": jsonrpc, - }, - name_handle_rpc_params.NameHandleRpcParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=object, - ) - - def rpc( - self, - agent_name: str, - *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: name_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, - # 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, - ) -> object: - """ - Handle JSON-RPC requests for an agent by its unique name. - - Args: - 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 - """ - if not agent_name: - raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") - return self._post( - f"/agents/name/{agent_name}/rpc", - body=maybe_transform( - { - "method": method, - "params": params, - "id": id, - "jsonrpc": jsonrpc, - }, - name_rpc_params.NameRpcParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=object, - ) - - -class AsyncNameResource(AsyncAPIResource): - @cached_property - def with_raw_response(self) -> AsyncNameResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers - """ - return AsyncNameResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> AsyncNameResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response - """ - return AsyncNameResourceWithStreamingResponse(self) - - async def retrieve( - self, - agent_name: str, - *, - # 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, - ) -> Agent: - """ - Get an agent by its unique name. - - Args: - 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 - """ - if not agent_name: - raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") - return await self._get( - f"/agents/name/{agent_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Agent, - ) - - async def delete( - self, - agent_name: str, - *, - # 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, - ) -> Agent: - """ - Delete an agent by its unique name. - - Args: - 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 - """ - if not agent_name: - raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") - return await self._delete( - f"/agents/name/{agent_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Agent, - ) - - async def handle_rpc( - self, - agent_name: str, - *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: name_handle_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, - # 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, - ) -> object: - """ - Handle JSON-RPC requests for an agent by its unique name. - - Args: - 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 - """ - if not agent_name: - raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") - return await self._post( - f"/agents/name/{agent_name}/rpc", - body=await async_maybe_transform( - { - "method": method, - "params": params, - "id": id, - "jsonrpc": jsonrpc, - }, - name_handle_rpc_params.NameHandleRpcParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=object, - ) - - async def rpc( - self, - agent_name: str, - *, - method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: name_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, - # 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, - ) -> object: - """ - Handle JSON-RPC requests for an agent by its unique name. - - Args: - 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 - """ - if not agent_name: - raise ValueError(f"Expected a non-empty value for `agent_name` but received {agent_name!r}") - return await self._post( - f"/agents/name/{agent_name}/rpc", - body=await async_maybe_transform( - { - "method": method, - "params": params, - "id": id, - "jsonrpc": jsonrpc, - }, - name_rpc_params.NameRpcParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=object, - ) - - -class NameResourceWithRawResponse: - def __init__(self, name: NameResource) -> None: - self._name = name - - self.retrieve = to_raw_response_wrapper( - name.retrieve, - ) - self.delete = to_raw_response_wrapper( - name.delete, - ) - self.handle_rpc = to_raw_response_wrapper( - name.handle_rpc, - ) - self.rpc = to_raw_response_wrapper( - name.rpc, - ) - - -class AsyncNameResourceWithRawResponse: - def __init__(self, name: AsyncNameResource) -> None: - self._name = name - - self.retrieve = async_to_raw_response_wrapper( - name.retrieve, - ) - self.delete = async_to_raw_response_wrapper( - name.delete, - ) - self.handle_rpc = async_to_raw_response_wrapper( - name.handle_rpc, - ) - self.rpc = async_to_raw_response_wrapper( - name.rpc, - ) - - -class NameResourceWithStreamingResponse: - def __init__(self, name: NameResource) -> None: - self._name = name - - self.retrieve = to_streamed_response_wrapper( - name.retrieve, - ) - self.delete = to_streamed_response_wrapper( - name.delete, - ) - self.handle_rpc = to_streamed_response_wrapper( - name.handle_rpc, - ) - self.rpc = to_streamed_response_wrapper( - name.rpc, - ) - - -class AsyncNameResourceWithStreamingResponse: - def __init__(self, name: AsyncNameResource) -> None: - self._name = name - - self.retrieve = async_to_streamed_response_wrapper( - name.retrieve, - ) - self.delete = async_to_streamed_response_wrapper( - name.delete, - ) - self.handle_rpc = async_to_streamed_response_wrapper( - name.handle_rpc, - ) - self.rpc = async_to_streamed_response_wrapper( - name.rpc, - ) diff --git a/src/agentex/resources/tasks/tasks.py b/src/agentex/resources/tasks.py similarity index 94% rename from src/agentex/resources/tasks/tasks.py rename to src/agentex/resources/tasks.py index ce1a7813..936ee66c 100644 --- a/src/agentex/resources/tasks/tasks.py +++ b/src/agentex/resources/tasks.py @@ -4,36 +4,24 @@ import httpx -from .name import ( - NameResource, - AsyncNameResource, - NameResourceWithRawResponse, - AsyncNameResourceWithRawResponse, - NameResourceWithStreamingResponse, - AsyncNameResourceWithStreamingResponse, -) -from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from ..._compat import cached_property -from ..._resource import SyncAPIResource, AsyncAPIResource -from ..._response import ( +from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._compat import cached_property +from .._resource import SyncAPIResource, AsyncAPIResource +from .._response import ( to_raw_response_wrapper, to_streamed_response_wrapper, async_to_raw_response_wrapper, async_to_streamed_response_wrapper, ) -from ..._streaming import Stream, AsyncStream -from ...types.task import Task -from ..._base_client import make_request_options -from ...types.task_list_response import TaskListResponse +from .._streaming import Stream, AsyncStream +from ..types.task import Task +from .._base_client import make_request_options +from ..types.task_list_response import TaskListResponse __all__ = ["TasksResource", "AsyncTasksResource"] class TasksResource(SyncAPIResource): - @cached_property - def name(self) -> NameResource: - return NameResource(self._client) - @cached_property def with_raw_response(self) -> TasksResourceWithRawResponse: """ @@ -276,10 +264,6 @@ def stream_events_by_name( class AsyncTasksResource(AsyncAPIResource): - @cached_property - def name(self) -> AsyncNameResource: - return AsyncNameResource(self._client) - @cached_property def with_raw_response(self) -> AsyncTasksResourceWithRawResponse: """ @@ -547,10 +531,6 @@ def __init__(self, tasks: TasksResource) -> None: tasks.stream_events_by_name, ) - @cached_property - def name(self) -> NameResourceWithRawResponse: - return NameResourceWithRawResponse(self._tasks.name) - class AsyncTasksResourceWithRawResponse: def __init__(self, tasks: AsyncTasksResource) -> None: @@ -578,10 +558,6 @@ def __init__(self, tasks: AsyncTasksResource) -> None: tasks.stream_events_by_name, ) - @cached_property - def name(self) -> AsyncNameResourceWithRawResponse: - return AsyncNameResourceWithRawResponse(self._tasks.name) - class TasksResourceWithStreamingResponse: def __init__(self, tasks: TasksResource) -> None: @@ -609,10 +585,6 @@ def __init__(self, tasks: TasksResource) -> None: tasks.stream_events_by_name, ) - @cached_property - def name(self) -> NameResourceWithStreamingResponse: - return NameResourceWithStreamingResponse(self._tasks.name) - class AsyncTasksResourceWithStreamingResponse: def __init__(self, tasks: AsyncTasksResource) -> None: @@ -639,7 +611,3 @@ def __init__(self, tasks: AsyncTasksResource) -> None: self.stream_events_by_name = async_to_streamed_response_wrapper( tasks.stream_events_by_name, ) - - @cached_property - def name(self) -> AsyncNameResourceWithStreamingResponse: - return AsyncNameResourceWithStreamingResponse(self._tasks.name) diff --git a/src/agentex/resources/tasks/__init__.py b/src/agentex/resources/tasks/__init__.py deleted file mode 100644 index 5a9c81b0..00000000 --- a/src/agentex/resources/tasks/__init__.py +++ /dev/null @@ -1,33 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .name import ( - NameResource, - AsyncNameResource, - NameResourceWithRawResponse, - AsyncNameResourceWithRawResponse, - NameResourceWithStreamingResponse, - AsyncNameResourceWithStreamingResponse, -) -from .tasks import ( - TasksResource, - AsyncTasksResource, - TasksResourceWithRawResponse, - AsyncTasksResourceWithRawResponse, - TasksResourceWithStreamingResponse, - AsyncTasksResourceWithStreamingResponse, -) - -__all__ = [ - "NameResource", - "AsyncNameResource", - "NameResourceWithRawResponse", - "AsyncNameResourceWithRawResponse", - "NameResourceWithStreamingResponse", - "AsyncNameResourceWithStreamingResponse", - "TasksResource", - "AsyncTasksResource", - "TasksResourceWithRawResponse", - "AsyncTasksResourceWithRawResponse", - "TasksResourceWithStreamingResponse", - "AsyncTasksResourceWithStreamingResponse", -] diff --git a/src/agentex/resources/tasks/name.py b/src/agentex/resources/tasks/name.py deleted file mode 100644 index 7cef42eb..00000000 --- a/src/agentex/resources/tasks/name.py +++ /dev/null @@ -1,324 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -import httpx - -from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from ..._compat import cached_property -from ..._resource import SyncAPIResource, AsyncAPIResource -from ..._response import ( - to_raw_response_wrapper, - to_streamed_response_wrapper, - async_to_raw_response_wrapper, - async_to_streamed_response_wrapper, -) -from ..._streaming import Stream, AsyncStream -from ...types.task import Task -from ..._base_client import make_request_options - -__all__ = ["NameResource", "AsyncNameResource"] - - -class NameResource(SyncAPIResource): - @cached_property - def with_raw_response(self) -> NameResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers - """ - return NameResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> NameResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response - """ - return NameResourceWithStreamingResponse(self) - - def retrieve( - self, - task_name: str, - *, - # 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, - ) -> Task: - """ - Get a task by its unique name. - - Args: - 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 - """ - if not task_name: - raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") - return self._get( - f"/tasks/name/{task_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Task, - ) - - def delete( - self, - task_name: str, - *, - # 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, - ) -> Task: - """ - Delete a task by its unique name. - - Args: - 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 - """ - if not task_name: - raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") - return self._delete( - f"/tasks/name/{task_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Task, - ) - - def stream_events( - self, - task_name: str, - *, - # 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, - ) -> Stream[object]: - """ - Stream events for a task by its unique name. - - Args: - 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 - """ - if not task_name: - raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") - return self._get( - f"/tasks/name/{task_name}/stream", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=object, - stream=True, - stream_cls=Stream[object], - ) - - -class AsyncNameResource(AsyncAPIResource): - @cached_property - def with_raw_response(self) -> AsyncNameResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers - """ - return AsyncNameResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> AsyncNameResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response - """ - return AsyncNameResourceWithStreamingResponse(self) - - async def retrieve( - self, - task_name: str, - *, - # 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, - ) -> Task: - """ - Get a task by its unique name. - - Args: - 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 - """ - if not task_name: - raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") - return await self._get( - f"/tasks/name/{task_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Task, - ) - - async def delete( - self, - task_name: str, - *, - # 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, - ) -> Task: - """ - Delete a task by its unique name. - - Args: - 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 - """ - if not task_name: - raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") - return await self._delete( - f"/tasks/name/{task_name}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=Task, - ) - - async def stream_events( - self, - task_name: str, - *, - # 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, - ) -> AsyncStream[object]: - """ - Stream events for a task by its unique name. - - Args: - 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 - """ - if not task_name: - raise ValueError(f"Expected a non-empty value for `task_name` but received {task_name!r}") - return await self._get( - f"/tasks/name/{task_name}/stream", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=object, - stream=True, - stream_cls=AsyncStream[object], - ) - - -class NameResourceWithRawResponse: - def __init__(self, name: NameResource) -> None: - self._name = name - - self.retrieve = to_raw_response_wrapper( - name.retrieve, - ) - self.delete = to_raw_response_wrapper( - name.delete, - ) - self.stream_events = to_raw_response_wrapper( - name.stream_events, - ) - - -class AsyncNameResourceWithRawResponse: - def __init__(self, name: AsyncNameResource) -> None: - self._name = name - - self.retrieve = async_to_raw_response_wrapper( - name.retrieve, - ) - self.delete = async_to_raw_response_wrapper( - name.delete, - ) - self.stream_events = async_to_raw_response_wrapper( - name.stream_events, - ) - - -class NameResourceWithStreamingResponse: - def __init__(self, name: NameResource) -> None: - self._name = name - - self.retrieve = to_streamed_response_wrapper( - name.retrieve, - ) - self.delete = to_streamed_response_wrapper( - name.delete, - ) - self.stream_events = to_streamed_response_wrapper( - name.stream_events, - ) - - -class AsyncNameResourceWithStreamingResponse: - def __init__(self, name: AsyncNameResource) -> None: - self._name = name - - self.retrieve = async_to_streamed_response_wrapper( - name.retrieve, - ) - self.delete = async_to_streamed_response_wrapper( - name.delete, - ) - self.stream_events = async_to_streamed_response_wrapper( - name.stream_events, - ) diff --git a/src/agentex/types/agents/__init__.py b/src/agentex/types/agents/__init__.py deleted file mode 100644 index 6211202a..00000000 --- a/src/agentex/types/agents/__init__.py +++ /dev/null @@ -1,6 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from .name_rpc_params import NameRpcParams as NameRpcParams -from .name_handle_rpc_params import NameHandleRpcParams as NameHandleRpcParams diff --git a/src/agentex/types/agents/name_handle_rpc_params.py b/src/agentex/types/agents/name_handle_rpc_params.py deleted file mode 100644 index d1d903a6..00000000 --- a/src/agentex/types/agents/name_handle_rpc_params.py +++ /dev/null @@ -1,85 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Dict, Union, Optional -from typing_extensions import Literal, Required, TypeAlias, TypedDict - -from ..data_content_param import DataContentParam -from ..text_content_param import TextContentParam -from ..tool_request_content_param import ToolRequestContentParam -from ..tool_response_content_param import ToolResponseContentParam - -__all__ = [ - "NameHandleRpcParams", - "Params", - "ParamsCreateTaskRequest", - "ParamsCancelTaskRequest", - "ParamsSendMessageRequest", - "ParamsSendMessageRequestContent", - "ParamsSendEventRequest", - "ParamsSendEventRequestContent", -] - - -class NameHandleRpcParams(TypedDict, total=False): - method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] - - params: Required[Params] - - id: Union[int, str, None] - - jsonrpc: Literal["2.0"] - - -class ParamsCreateTaskRequest(TypedDict, total=False): - name: Optional[str] - """The name of the task to create""" - - params: Optional[Dict[str, object]] - """The parameters for the task""" - - -class ParamsCancelTaskRequest(TypedDict, total=False): - task_id: Optional[str] - """The ID of the task to cancel. Either this or task_name must be provided.""" - - task_name: Optional[str] - """The name of the task to cancel. Either this or task_id must be provided.""" - - -ParamsSendMessageRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendMessageRequest(TypedDict, total=False): - content: Required[ParamsSendMessageRequestContent] - """The message that was sent to the agent""" - - stream: bool - """Whether to stream the response message back to the client""" - - task_id: Optional[str] - """The ID of the task that the message was sent to""" - - -ParamsSendEventRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendEventRequest(TypedDict, total=False): - content: Optional[ParamsSendEventRequestContent] - """The content to send to the event""" - - task_id: Optional[str] - """The ID of the task that the event was sent to""" - - task_name: Optional[str] - """The name of the task that the event was sent to""" - - -Params: TypeAlias = Union[ - ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest -] diff --git a/src/agentex/types/agents/name_rpc_params.py b/src/agentex/types/agents/name_rpc_params.py deleted file mode 100644 index 6a68b0ba..00000000 --- a/src/agentex/types/agents/name_rpc_params.py +++ /dev/null @@ -1,85 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Dict, Union, Optional -from typing_extensions import Literal, Required, TypeAlias, TypedDict - -from ..data_content_param import DataContentParam -from ..text_content_param import TextContentParam -from ..tool_request_content_param import ToolRequestContentParam -from ..tool_response_content_param import ToolResponseContentParam - -__all__ = [ - "NameRpcParams", - "Params", - "ParamsCreateTaskRequest", - "ParamsCancelTaskRequest", - "ParamsSendMessageRequest", - "ParamsSendMessageRequestContent", - "ParamsSendEventRequest", - "ParamsSendEventRequestContent", -] - - -class NameRpcParams(TypedDict, total=False): - method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] - - params: Required[Params] - - id: Union[int, str, None] - - jsonrpc: Literal["2.0"] - - -class ParamsCreateTaskRequest(TypedDict, total=False): - name: Optional[str] - """The name of the task to create""" - - params: Optional[Dict[str, object]] - """The parameters for the task""" - - -class ParamsCancelTaskRequest(TypedDict, total=False): - task_id: Optional[str] - """The ID of the task to cancel. Either this or task_name must be provided.""" - - task_name: Optional[str] - """The name of the task to cancel. Either this or task_id must be provided.""" - - -ParamsSendMessageRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendMessageRequest(TypedDict, total=False): - content: Required[ParamsSendMessageRequestContent] - """The message that was sent to the agent""" - - stream: bool - """Whether to stream the response message back to the client""" - - task_id: Optional[str] - """The ID of the task that the message was sent to""" - - -ParamsSendEventRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendEventRequest(TypedDict, total=False): - content: Optional[ParamsSendEventRequestContent] - """The content to send to the event""" - - task_id: Optional[str] - """The ID of the task that the event was sent to""" - - task_name: Optional[str] - """The name of the task that the event was sent to""" - - -Params: TypeAlias = Union[ - ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest -] diff --git a/src/agentex/types/tasks/__init__.py b/src/agentex/types/tasks/__init__.py deleted file mode 100644 index f8ee8b14..00000000 --- a/src/agentex/types/tasks/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations diff --git a/tests/api_resources/agents/__init__.py b/tests/api_resources/agents/__init__.py deleted file mode 100644 index fd8019a9..00000000 --- a/tests/api_resources/agents/__init__.py +++ /dev/null @@ -1 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/agents/test_name.py b/tests/api_resources/agents/test_name.py deleted file mode 100644 index dea82f12..00000000 --- a/tests/api_resources/agents/test_name.py +++ /dev/null @@ -1,452 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -import os -from typing import Any, cast - -import pytest - -from agentex import Agentex, AsyncAgentex -from tests.utils import assert_matches_type -from agentex.types import Agent - -base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") - - -class TestName: - parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - - @pytest.mark.skip() - @parametrize - def test_method_retrieve(self, client: Agentex) -> None: - name = client.agents.name.retrieve( - "agent_name", - ) - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_retrieve(self, client: Agentex) -> None: - response = client.agents.name.with_raw_response.retrieve( - "agent_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = response.parse() - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_retrieve(self, client: Agentex) -> None: - with client.agents.name.with_streaming_response.retrieve( - "agent_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = response.parse() - assert_matches_type(Agent, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - def test_path_params_retrieve(self, client: Agentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - client.agents.name.with_raw_response.retrieve( - "", - ) - - @pytest.mark.skip() - @parametrize - def test_method_delete(self, client: Agentex) -> None: - name = client.agents.name.delete( - "agent_name", - ) - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_delete(self, client: Agentex) -> None: - response = client.agents.name.with_raw_response.delete( - "agent_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = response.parse() - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_delete(self, client: Agentex) -> None: - with client.agents.name.with_streaming_response.delete( - "agent_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = response.parse() - assert_matches_type(Agent, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - def test_path_params_delete(self, client: Agentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - client.agents.name.with_raw_response.delete( - "", - ) - - @pytest.mark.skip() - @parametrize - def test_method_handle_rpc(self, client: Agentex) -> None: - name = client.agents.name.handle_rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_method_handle_rpc_with_all_params(self, client: Agentex) -> None: - name = client.agents.name.handle_rpc( - agent_name="agent_name", - method="event/send", - params={ - "name": "name", - "params": {"foo": "bar"}, - }, - id=0, - jsonrpc="2.0", - ) - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_handle_rpc(self, client: Agentex) -> None: - response = client.agents.name.with_raw_response.handle_rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = response.parse() - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_handle_rpc(self, client: Agentex) -> None: - with client.agents.name.with_streaming_response.handle_rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = response.parse() - assert_matches_type(object, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - def test_path_params_handle_rpc(self, client: Agentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - client.agents.name.with_raw_response.handle_rpc( - agent_name="", - method="event/send", - params={}, - ) - - @pytest.mark.skip() - @parametrize - def test_method_rpc(self, client: Agentex) -> None: - name = client.agents.name.rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_method_rpc_with_all_params(self, client: Agentex) -> None: - name = client.agents.name.rpc( - agent_name="agent_name", - method="event/send", - params={ - "name": "name", - "params": {"foo": "bar"}, - }, - id=0, - jsonrpc="2.0", - ) - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_rpc(self, client: Agentex) -> None: - response = client.agents.name.with_raw_response.rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = response.parse() - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_rpc(self, client: Agentex) -> None: - with client.agents.name.with_streaming_response.rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = response.parse() - assert_matches_type(object, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - def test_path_params_rpc(self, client: Agentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - client.agents.name.with_raw_response.rpc( - agent_name="", - method="event/send", - params={}, - ) - - -class TestAsyncName: - parametrize = pytest.mark.parametrize( - "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] - ) - - @pytest.mark.skip() - @parametrize - async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: - name = await async_client.agents.name.retrieve( - "agent_name", - ) - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: - response = await async_client.agents.name.with_raw_response.retrieve( - "agent_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = await response.parse() - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: - async with async_client.agents.name.with_streaming_response.retrieve( - "agent_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = await response.parse() - assert_matches_type(Agent, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - await async_client.agents.name.with_raw_response.retrieve( - "", - ) - - @pytest.mark.skip() - @parametrize - async def test_method_delete(self, async_client: AsyncAgentex) -> None: - name = await async_client.agents.name.delete( - "agent_name", - ) - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: - response = await async_client.agents.name.with_raw_response.delete( - "agent_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = await response.parse() - assert_matches_type(Agent, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> None: - async with async_client.agents.name.with_streaming_response.delete( - "agent_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = await response.parse() - assert_matches_type(Agent, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - await async_client.agents.name.with_raw_response.delete( - "", - ) - - @pytest.mark.skip() - @parametrize - async def test_method_handle_rpc(self, async_client: AsyncAgentex) -> None: - name = await async_client.agents.name.handle_rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_method_handle_rpc_with_all_params(self, async_client: AsyncAgentex) -> None: - name = await async_client.agents.name.handle_rpc( - agent_name="agent_name", - method="event/send", - params={ - "name": "name", - "params": {"foo": "bar"}, - }, - id=0, - jsonrpc="2.0", - ) - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_handle_rpc(self, async_client: AsyncAgentex) -> None: - response = await async_client.agents.name.with_raw_response.handle_rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = await response.parse() - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_handle_rpc(self, async_client: AsyncAgentex) -> None: - async with async_client.agents.name.with_streaming_response.handle_rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = await response.parse() - assert_matches_type(object, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - async def test_path_params_handle_rpc(self, async_client: AsyncAgentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - await async_client.agents.name.with_raw_response.handle_rpc( - agent_name="", - method="event/send", - params={}, - ) - - @pytest.mark.skip() - @parametrize - async def test_method_rpc(self, async_client: AsyncAgentex) -> None: - name = await async_client.agents.name.rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_method_rpc_with_all_params(self, async_client: AsyncAgentex) -> None: - name = await async_client.agents.name.rpc( - agent_name="agent_name", - method="event/send", - params={ - "name": "name", - "params": {"foo": "bar"}, - }, - id=0, - jsonrpc="2.0", - ) - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_rpc(self, async_client: AsyncAgentex) -> None: - response = await async_client.agents.name.with_raw_response.rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = await response.parse() - assert_matches_type(object, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_rpc(self, async_client: AsyncAgentex) -> None: - async with async_client.agents.name.with_streaming_response.rpc( - agent_name="agent_name", - method="event/send", - params={}, - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = await response.parse() - assert_matches_type(object, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - async def test_path_params_rpc(self, async_client: AsyncAgentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): - await async_client.agents.name.with_raw_response.rpc( - agent_name="", - method="event/send", - params={}, - ) diff --git a/tests/api_resources/tasks/__init__.py b/tests/api_resources/tasks/__init__.py deleted file mode 100644 index fd8019a9..00000000 --- a/tests/api_resources/tasks/__init__.py +++ /dev/null @@ -1 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/tasks/test_name.py b/tests/api_resources/tasks/test_name.py deleted file mode 100644 index cb000659..00000000 --- a/tests/api_resources/tasks/test_name.py +++ /dev/null @@ -1,274 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -import os -from typing import Any, cast - -import pytest - -from agentex import Agentex, AsyncAgentex -from tests.utils import assert_matches_type -from agentex.types import Task - -base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") - - -class TestName: - parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - - @pytest.mark.skip() - @parametrize - def test_method_retrieve(self, client: Agentex) -> None: - name = client.tasks.name.retrieve( - "task_name", - ) - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_retrieve(self, client: Agentex) -> None: - response = client.tasks.name.with_raw_response.retrieve( - "task_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = response.parse() - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_retrieve(self, client: Agentex) -> None: - with client.tasks.name.with_streaming_response.retrieve( - "task_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = response.parse() - assert_matches_type(Task, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - def test_path_params_retrieve(self, client: Agentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): - client.tasks.name.with_raw_response.retrieve( - "", - ) - - @pytest.mark.skip() - @parametrize - def test_method_delete(self, client: Agentex) -> None: - name = client.tasks.name.delete( - "task_name", - ) - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_delete(self, client: Agentex) -> None: - response = client.tasks.name.with_raw_response.delete( - "task_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = response.parse() - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_delete(self, client: Agentex) -> None: - with client.tasks.name.with_streaming_response.delete( - "task_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = response.parse() - assert_matches_type(Task, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - def test_path_params_delete(self, client: Agentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): - client.tasks.name.with_raw_response.delete( - "", - ) - - @pytest.mark.skip() - @parametrize - def test_method_stream_events(self, client: Agentex) -> None: - name_stream = client.tasks.name.stream_events( - "task_name", - ) - name_stream.response.close() - - @pytest.mark.skip() - @parametrize - def test_raw_response_stream_events(self, client: Agentex) -> None: - response = client.tasks.name.with_raw_response.stream_events( - "task_name", - ) - - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - stream = response.parse() - stream.close() - - @pytest.mark.skip() - @parametrize - def test_streaming_response_stream_events(self, client: Agentex) -> None: - with client.tasks.name.with_streaming_response.stream_events( - "task_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - stream = response.parse() - stream.close() - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - def test_path_params_stream_events(self, client: Agentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): - client.tasks.name.with_raw_response.stream_events( - "", - ) - - -class TestAsyncName: - parametrize = pytest.mark.parametrize( - "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] - ) - - @pytest.mark.skip() - @parametrize - async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: - name = await async_client.tasks.name.retrieve( - "task_name", - ) - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: - response = await async_client.tasks.name.with_raw_response.retrieve( - "task_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = await response.parse() - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: - async with async_client.tasks.name.with_streaming_response.retrieve( - "task_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = await response.parse() - assert_matches_type(Task, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): - await async_client.tasks.name.with_raw_response.retrieve( - "", - ) - - @pytest.mark.skip() - @parametrize - async def test_method_delete(self, async_client: AsyncAgentex) -> None: - name = await async_client.tasks.name.delete( - "task_name", - ) - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: - response = await async_client.tasks.name.with_raw_response.delete( - "task_name", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - name = await response.parse() - assert_matches_type(Task, name, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> None: - async with async_client.tasks.name.with_streaming_response.delete( - "task_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - name = await response.parse() - assert_matches_type(Task, name, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): - await async_client.tasks.name.with_raw_response.delete( - "", - ) - - @pytest.mark.skip() - @parametrize - async def test_method_stream_events(self, async_client: AsyncAgentex) -> None: - name_stream = await async_client.tasks.name.stream_events( - "task_name", - ) - await name_stream.response.aclose() - - @pytest.mark.skip() - @parametrize - async def test_raw_response_stream_events(self, async_client: AsyncAgentex) -> None: - response = await async_client.tasks.name.with_raw_response.stream_events( - "task_name", - ) - - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - stream = await response.parse() - await stream.close() - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_stream_events(self, async_client: AsyncAgentex) -> None: - async with async_client.tasks.name.with_streaming_response.stream_events( - "task_name", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - stream = await response.parse() - await stream.close() - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() - @parametrize - async def test_path_params_stream_events(self, async_client: AsyncAgentex) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): - await async_client.tasks.name.with_raw_response.stream_events( - "", - ) From 5209e8c029b6b89be9f1f022599eb4fa0d7f5130 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 23 Jul 2025 00:03:14 +0000 Subject: [PATCH 0033/1108] feat(api): manual updates --- .stats.yml | 4 +- api.md | 14 +- src/agentex/resources/agents.py | 26 ++- src/agentex/resources/messages/messages.py | 12 +- src/agentex/types/__init__.py | 3 +- src/agentex/types/agent_rpc_by_name_params.py | 1 + .../types/agent_rpc_by_name_response.py | 165 ++++++++++++++++++ src/agentex/types/agent_rpc_params.py | 1 + src/agentex/types/agent_rpc_response.py | 165 ++++++++++++++++++ src/agentex/types/message_create_params.py | 5 +- src/agentex/types/message_update_params.py | 5 +- src/agentex/types/streaming_status.py | 7 - src/agentex/types/task_message.py | 21 ++- tests/api_resources/test_agents.py | 39 +++-- 14 files changed, 409 insertions(+), 59 deletions(-) create mode 100644 src/agentex/types/agent_rpc_by_name_response.py create mode 100644 src/agentex/types/agent_rpc_response.py delete mode 100644 src/agentex/types/streaming_status.py diff --git a/.stats.yml b/.stats.yml index a111f762..e880ba66 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-021b55c88964b7a5bfc9d692d32a52c6b0150445656d2407c4cb8e9dd1e5f100.yml -openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1d08fb2290b5310c91801d7575d356628d372fd5434e15d3b9cead48eadb893f.yml +openapi_spec_hash: c07c588fb8429fbf024189df62f20fa4 config_hash: 5a41a91d658dffbd60d617eb02e945f6 diff --git a/api.md b/api.md index 8c2841ca..474200e1 100644 --- a/api.md +++ b/api.md @@ -3,7 +3,14 @@ Types: ```python -from agentex.types import AcpType, Agent, AgentRpcRequest, AgentListResponse +from agentex.types import ( + AcpType, + Agent, + AgentRpcRequest, + AgentListResponse, + AgentRpcResponse, + AgentRpcByNameResponse, +) ``` Methods: @@ -13,8 +20,8 @@ Methods: - client.agents.delete(agent_id) -> Agent - client.agents.delete_by_name(agent_name) -> Agent - client.agents.retrieve_by_name(agent_name) -> Agent -- client.agents.rpc(agent_id, \*\*params) -> object -- client.agents.rpc_by_name(agent_name, \*\*params) -> object +- client.agents.rpc(agent_id, \*\*params) -> AgentRpcResponse +- client.agents.rpc_by_name(agent_name, \*\*params) -> AgentRpcByNameResponse # Tasks @@ -43,7 +50,6 @@ from agentex.types import ( DataContent, MessageAuthor, MessageStyle, - StreamingStatus, TaskMessage, TextContent, ToolRequestContent, diff --git a/src/agentex/resources/agents.py b/src/agentex/resources/agents.py index 9c2e4bd5..3e5626c6 100644 --- a/src/agentex/resources/agents.py +++ b/src/agentex/resources/agents.py @@ -20,7 +20,9 @@ ) from ..types.agent import Agent from .._base_client import make_request_options +from ..types.agent_rpc_response import AgentRpcResponse from ..types.agent_list_response import AgentListResponse +from ..types.agent_rpc_by_name_response import AgentRpcByNameResponse __all__ = ["AgentsResource", "AsyncAgentsResource"] @@ -228,11 +230,13 @@ def rpc( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> object: + ) -> AgentRpcResponse: """ Handle JSON-RPC requests for an agent by its unique ID. Args: + params: The parameters for the agent RPC request + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -257,7 +261,7 @@ def rpc( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=object, + cast_to=AgentRpcResponse, ) def rpc_by_name( @@ -274,11 +278,13 @@ def rpc_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> object: + ) -> AgentRpcByNameResponse: """ Handle JSON-RPC requests for an agent by its unique name. Args: + params: The parameters for the agent RPC request + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -303,7 +309,7 @@ def rpc_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=object, + cast_to=AgentRpcByNameResponse, ) @@ -510,11 +516,13 @@ async def rpc( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> object: + ) -> AgentRpcResponse: """ Handle JSON-RPC requests for an agent by its unique ID. Args: + params: The parameters for the agent RPC request + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -539,7 +547,7 @@ async def rpc( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=object, + cast_to=AgentRpcResponse, ) async def rpc_by_name( @@ -556,11 +564,13 @@ async def rpc_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> object: + ) -> AgentRpcByNameResponse: """ Handle JSON-RPC requests for an agent by its unique name. Args: + params: The parameters for the agent RPC request + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -585,7 +595,7 @@ async def rpc_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=object, + cast_to=AgentRpcByNameResponse, ) diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index 7745cf76..2d83fb4e 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -3,6 +3,7 @@ from __future__ import annotations from typing import Optional +from typing_extensions import Literal import httpx @@ -14,7 +15,7 @@ BatchResourceWithStreamingResponse, AsyncBatchResourceWithStreamingResponse, ) -from ...types import StreamingStatus, message_list_params, message_create_params, message_update_params +from ...types import message_list_params, message_create_params, message_update_params from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property @@ -27,7 +28,6 @@ ) from ..._base_client import make_request_options from ...types.task_message import TaskMessage -from ...types.streaming_status import StreamingStatus from ...types.message_list_response import MessageListResponse __all__ = ["MessagesResource", "AsyncMessagesResource"] @@ -62,7 +62,7 @@ def create( *, content: message_create_params.Content, task_id: str, - streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # 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, @@ -137,7 +137,7 @@ def update( *, content: message_update_params.Content, task_id: str, - streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # 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, @@ -247,7 +247,7 @@ async def create( *, content: message_create_params.Content, task_id: str, - streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # 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, @@ -322,7 +322,7 @@ async def update( *, content: message_update_params.Content, task_id: str, - streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # 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, diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index a5e72143..5a380cdc 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -15,10 +15,10 @@ from .message_author import MessageAuthor as MessageAuthor from .agent_rpc_params import AgentRpcParams as AgentRpcParams from .span_list_params import SpanListParams as SpanListParams -from .streaming_status import StreamingStatus as StreamingStatus from .agent_list_params import AgentListParams as AgentListParams from .event_list_params import EventListParams as EventListParams from .state_list_params import StateListParams as StateListParams +from .agent_rpc_response import AgentRpcResponse as AgentRpcResponse from .agent_task_tracker import AgentTaskTracker as AgentTaskTracker from .data_content_param import DataContentParam as DataContentParam from .span_create_params import SpanCreateParams as SpanCreateParams @@ -41,5 +41,6 @@ from .tracker_list_response import TrackerListResponse as TrackerListResponse from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams from .agent_rpc_by_name_params import AgentRpcByNameParams as AgentRpcByNameParams +from .agent_rpc_by_name_response import AgentRpcByNameResponse as AgentRpcByNameResponse from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam diff --git a/src/agentex/types/agent_rpc_by_name_params.py b/src/agentex/types/agent_rpc_by_name_params.py index 5014a076..191081cc 100644 --- a/src/agentex/types/agent_rpc_by_name_params.py +++ b/src/agentex/types/agent_rpc_by_name_params.py @@ -26,6 +26,7 @@ class AgentRpcByNameParams(TypedDict, total=False): method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] params: Required[Params] + """The parameters for the agent RPC request""" id: Union[int, str, None] diff --git a/src/agentex/types/agent_rpc_by_name_response.py b/src/agentex/types/agent_rpc_by_name_response.py new file mode 100644 index 00000000..05317965 --- /dev/null +++ b/src/agentex/types/agent_rpc_by_name_response.py @@ -0,0 +1,165 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Union, Optional +from typing_extensions import Literal, Annotated, TypeAlias + +from .task import Task +from .event import Event +from .._utils import PropertyInfo +from .._models import BaseModel +from .data_content import DataContent +from .task_message import TaskMessage +from .text_content import TextContent +from .tool_request_content import ToolRequestContent +from .tool_response_content import ToolResponseContent + +__all__ = [ + "AgentRpcByNameResponse", + "Result", + "ResultStreamTaskMessageStart", + "ResultStreamTaskMessageStartContent", + "ResultStreamTaskMessageDelta", + "ResultStreamTaskMessageDeltaDelta", + "ResultStreamTaskMessageDeltaDeltaTextDelta", + "ResultStreamTaskMessageDeltaDeltaDataDelta", + "ResultStreamTaskMessageDeltaDeltaToolRequestDelta", + "ResultStreamTaskMessageDeltaDeltaToolResponseDelta", + "ResultStreamTaskMessageFull", + "ResultStreamTaskMessageFullContent", + "ResultStreamTaskMessageDone", +] + +ResultStreamTaskMessageStartContent: TypeAlias = Annotated[ + Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") +] + + +class ResultStreamTaskMessageStart(BaseModel): + content: ResultStreamTaskMessageStartContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["start"]] = None + + +class ResultStreamTaskMessageDeltaDeltaTextDelta(BaseModel): + text_delta: Optional[str] = None + + type: Optional[Literal["text"]] = None + + +class ResultStreamTaskMessageDeltaDeltaDataDelta(BaseModel): + data_delta: Optional[str] = None + + type: Optional[Literal["data"]] = None + + +class ResultStreamTaskMessageDeltaDeltaToolRequestDelta(BaseModel): + name: str + + tool_call_id: str + + arguments_delta: Optional[str] = None + + type: Optional[Literal["tool_request"]] = None + + +class ResultStreamTaskMessageDeltaDeltaToolResponseDelta(BaseModel): + name: str + + tool_call_id: str + + content_delta: Optional[str] = None + + type: Optional[Literal["tool_response"]] = None + + +ResultStreamTaskMessageDeltaDelta: TypeAlias = Annotated[ + Union[ + ResultStreamTaskMessageDeltaDeltaTextDelta, + ResultStreamTaskMessageDeltaDeltaDataDelta, + ResultStreamTaskMessageDeltaDeltaToolRequestDelta, + ResultStreamTaskMessageDeltaDeltaToolResponseDelta, + None, + ], + PropertyInfo(discriminator="type"), +] + + +class ResultStreamTaskMessageDelta(BaseModel): + delta: Optional[ResultStreamTaskMessageDeltaDelta] = None + """Delta for text updates""" + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["delta"]] = None + + +ResultStreamTaskMessageFullContent: TypeAlias = Annotated[ + Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") +] + + +class ResultStreamTaskMessageFull(BaseModel): + content: ResultStreamTaskMessageFullContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["full"]] = None + + +class ResultStreamTaskMessageDone(BaseModel): + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["done"]] = None + + +Result: TypeAlias = Union[ + List[TaskMessage], + ResultStreamTaskMessageStart, + ResultStreamTaskMessageDelta, + ResultStreamTaskMessageFull, + ResultStreamTaskMessageDone, + Task, + Event, + None, +] + + +class AgentRpcByNameResponse(BaseModel): + result: Optional[Result] = None + """The result of the agent RPC request""" + + id: Union[int, str, None] = None + + error: Optional[object] = None + + jsonrpc: Optional[Literal["2.0"]] = None diff --git a/src/agentex/types/agent_rpc_params.py b/src/agentex/types/agent_rpc_params.py index 2c79a7a9..4e83e75f 100644 --- a/src/agentex/types/agent_rpc_params.py +++ b/src/agentex/types/agent_rpc_params.py @@ -26,6 +26,7 @@ class AgentRpcParams(TypedDict, total=False): method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] params: Required[Params] + """The parameters for the agent RPC request""" id: Union[int, str, None] diff --git a/src/agentex/types/agent_rpc_response.py b/src/agentex/types/agent_rpc_response.py new file mode 100644 index 00000000..f67a8152 --- /dev/null +++ b/src/agentex/types/agent_rpc_response.py @@ -0,0 +1,165 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Union, Optional +from typing_extensions import Literal, Annotated, TypeAlias + +from .task import Task +from .event import Event +from .._utils import PropertyInfo +from .._models import BaseModel +from .data_content import DataContent +from .task_message import TaskMessage +from .text_content import TextContent +from .tool_request_content import ToolRequestContent +from .tool_response_content import ToolResponseContent + +__all__ = [ + "AgentRpcResponse", + "Result", + "ResultStreamTaskMessageStart", + "ResultStreamTaskMessageStartContent", + "ResultStreamTaskMessageDelta", + "ResultStreamTaskMessageDeltaDelta", + "ResultStreamTaskMessageDeltaDeltaTextDelta", + "ResultStreamTaskMessageDeltaDeltaDataDelta", + "ResultStreamTaskMessageDeltaDeltaToolRequestDelta", + "ResultStreamTaskMessageDeltaDeltaToolResponseDelta", + "ResultStreamTaskMessageFull", + "ResultStreamTaskMessageFullContent", + "ResultStreamTaskMessageDone", +] + +ResultStreamTaskMessageStartContent: TypeAlias = Annotated[ + Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") +] + + +class ResultStreamTaskMessageStart(BaseModel): + content: ResultStreamTaskMessageStartContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["start"]] = None + + +class ResultStreamTaskMessageDeltaDeltaTextDelta(BaseModel): + text_delta: Optional[str] = None + + type: Optional[Literal["text"]] = None + + +class ResultStreamTaskMessageDeltaDeltaDataDelta(BaseModel): + data_delta: Optional[str] = None + + type: Optional[Literal["data"]] = None + + +class ResultStreamTaskMessageDeltaDeltaToolRequestDelta(BaseModel): + name: str + + tool_call_id: str + + arguments_delta: Optional[str] = None + + type: Optional[Literal["tool_request"]] = None + + +class ResultStreamTaskMessageDeltaDeltaToolResponseDelta(BaseModel): + name: str + + tool_call_id: str + + content_delta: Optional[str] = None + + type: Optional[Literal["tool_response"]] = None + + +ResultStreamTaskMessageDeltaDelta: TypeAlias = Annotated[ + Union[ + ResultStreamTaskMessageDeltaDeltaTextDelta, + ResultStreamTaskMessageDeltaDeltaDataDelta, + ResultStreamTaskMessageDeltaDeltaToolRequestDelta, + ResultStreamTaskMessageDeltaDeltaToolResponseDelta, + None, + ], + PropertyInfo(discriminator="type"), +] + + +class ResultStreamTaskMessageDelta(BaseModel): + delta: Optional[ResultStreamTaskMessageDeltaDelta] = None + """Delta for text updates""" + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["delta"]] = None + + +ResultStreamTaskMessageFullContent: TypeAlias = Annotated[ + Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") +] + + +class ResultStreamTaskMessageFull(BaseModel): + content: ResultStreamTaskMessageFullContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["full"]] = None + + +class ResultStreamTaskMessageDone(BaseModel): + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["done"]] = None + + +Result: TypeAlias = Union[ + List[TaskMessage], + ResultStreamTaskMessageStart, + ResultStreamTaskMessageDelta, + ResultStreamTaskMessageFull, + ResultStreamTaskMessageDone, + Task, + Event, + None, +] + + +class AgentRpcResponse(BaseModel): + result: Optional[Result] = None + """The result of the agent RPC request""" + + id: Union[int, str, None] = None + + error: Optional[object] = None + + jsonrpc: Optional[Literal["2.0"]] = None diff --git a/src/agentex/types/message_create_params.py b/src/agentex/types/message_create_params.py index 06ec3727..4d59ca07 100644 --- a/src/agentex/types/message_create_params.py +++ b/src/agentex/types/message_create_params.py @@ -3,9 +3,8 @@ from __future__ import annotations from typing import Union, Optional -from typing_extensions import Required, TypeAlias, TypedDict +from typing_extensions import Literal, Required, TypeAlias, TypedDict -from .streaming_status import StreamingStatus from .data_content_param import DataContentParam from .text_content_param import TextContentParam from .tool_request_content_param import ToolRequestContentParam @@ -19,7 +18,7 @@ class MessageCreateParams(TypedDict, total=False): task_id: Required[str] - streaming_status: Optional[StreamingStatus] + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex/types/message_update_params.py b/src/agentex/types/message_update_params.py index bc5305b8..08ce8478 100644 --- a/src/agentex/types/message_update_params.py +++ b/src/agentex/types/message_update_params.py @@ -3,9 +3,8 @@ from __future__ import annotations from typing import Union, Optional -from typing_extensions import Required, TypeAlias, TypedDict +from typing_extensions import Literal, Required, TypeAlias, TypedDict -from .streaming_status import StreamingStatus from .data_content_param import DataContentParam from .text_content_param import TextContentParam from .tool_request_content_param import ToolRequestContentParam @@ -19,7 +18,7 @@ class MessageUpdateParams(TypedDict, total=False): task_id: Required[str] - streaming_status: Optional[StreamingStatus] + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex/types/streaming_status.py b/src/agentex/types/streaming_status.py deleted file mode 100644 index 196d7881..00000000 --- a/src/agentex/types/streaming_status.py +++ /dev/null @@ -1,7 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing_extensions import Literal, TypeAlias - -__all__ = ["StreamingStatus"] - -StreamingStatus: TypeAlias = Literal["IN_PROGRESS", "DONE"] diff --git a/src/agentex/types/task_message.py b/src/agentex/types/task_message.py index 686ade7d..29adf4d3 100644 --- a/src/agentex/types/task_message.py +++ b/src/agentex/types/task_message.py @@ -2,13 +2,12 @@ from typing import Union, Optional from datetime import datetime -from typing_extensions import Annotated, TypeAlias +from typing_extensions import Literal, Annotated, TypeAlias from .._utils import PropertyInfo from .._models import BaseModel from .data_content import DataContent from .text_content import TextContent -from .streaming_status import StreamingStatus from .tool_request_content import ToolRequestContent from .tool_response_content import ToolResponseContent @@ -20,17 +19,23 @@ class TaskMessage(BaseModel): - id: str - """The task message's unique id""" - content: Content + """The content of the message. - created_at: datetime - """The timestamp when the message was created""" + This content is not OpenAI compatible. These are messages that are meant to be + displayed to the user. + """ task_id: str + """ID of the task this message belongs to""" + + id: Optional[str] = None + """The task message's unique id""" + + created_at: Optional[datetime] = None + """The timestamp when the message was created""" - streaming_status: Optional[StreamingStatus] = None + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] = None updated_at: Optional[datetime] = None """The timestamp when the message was last updated""" diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index b2819f31..e415e011 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -9,7 +9,12 @@ from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type -from agentex.types import Agent, AgentListResponse +from agentex.types import ( + Agent, + AgentRpcResponse, + AgentListResponse, + AgentRpcByNameResponse, +) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -229,7 +234,7 @@ def test_method_rpc(self, client: Agentex) -> None: method="event/send", params={}, ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -244,7 +249,7 @@ def test_method_rpc_with_all_params(self, client: Agentex) -> None: id=0, jsonrpc="2.0", ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -258,7 +263,7 @@ def test_raw_response_rpc(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -272,7 +277,7 @@ def test_streaming_response_rpc(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -294,7 +299,7 @@ def test_method_rpc_by_name(self, client: Agentex) -> None: method="event/send", params={}, ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -309,7 +314,7 @@ def test_method_rpc_by_name_with_all_params(self, client: Agentex) -> None: id=0, jsonrpc="2.0", ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -323,7 +328,7 @@ def test_raw_response_rpc_by_name(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -337,7 +342,7 @@ def test_streaming_response_rpc_by_name(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -569,7 +574,7 @@ async def test_method_rpc(self, async_client: AsyncAgentex) -> None: method="event/send", params={}, ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -584,7 +589,7 @@ async def test_method_rpc_with_all_params(self, async_client: AsyncAgentex) -> N id=0, jsonrpc="2.0", ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -598,7 +603,7 @@ async def test_raw_response_rpc(self, async_client: AsyncAgentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -612,7 +617,7 @@ async def test_streaming_response_rpc(self, async_client: AsyncAgentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -634,7 +639,7 @@ async def test_method_rpc_by_name(self, async_client: AsyncAgentex) -> None: method="event/send", params={}, ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -649,7 +654,7 @@ async def test_method_rpc_by_name_with_all_params(self, async_client: AsyncAgent id=0, jsonrpc="2.0", ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -663,7 +668,7 @@ async def test_raw_response_rpc_by_name(self, async_client: AsyncAgentex) -> Non assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -677,7 +682,7 @@ async def test_streaming_response_rpc_by_name(self, async_client: AsyncAgentex) assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True From 5dada2d59e698cf5bb5b91aaa07316238dc1cf4f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 23 Jul 2025 00:04:04 +0000 Subject: [PATCH 0034/1108] feat(api): manual updates --- .stats.yml | 2 +- api.md | 20 ++- src/agentex/resources/agents.py | 20 +-- src/agentex/resources/messages/batch.py | 9 +- src/agentex/resources/messages/messages.py | 9 +- src/agentex/types/__init__.py | 10 +- src/agentex/types/agent_rpc_by_name_params.py | 75 +------- .../types/agent_rpc_by_name_response.py | 165 ------------------ src/agentex/types/agent_rpc_params.py | 55 ++---- src/agentex/types/agent_rpc_params1.py | 21 +++ src/agentex/types/agent_rpc_response.py | 155 +--------------- src/agentex/types/agent_rpc_result.py | 90 ++++++++++ src/agentex/types/data_delta.py | 14 ++ src/agentex/types/event.py | 17 +- src/agentex/types/message_create_params.py | 16 +- src/agentex/types/message_update_params.py | 16 +- .../types/messages/batch_create_params.py | 16 +- .../types/messages/batch_update_params.py | 16 +- src/agentex/types/shared/__init__.py | 3 + .../types/shared/task_message_update.py | 83 +++++++++ src/agentex/types/task_message.py | 18 +- src/agentex/types/task_message_content.py | 16 ++ .../types/task_message_content_param.py | 17 ++ src/agentex/types/task_message_delta.py | 16 ++ src/agentex/types/text_delta.py | 14 ++ src/agentex/types/tool_request_delta.py | 18 ++ src/agentex/types/tool_response_delta.py | 18 ++ tests/api_resources/test_agents.py | 17 +- 28 files changed, 414 insertions(+), 532 deletions(-) delete mode 100644 src/agentex/types/agent_rpc_by_name_response.py create mode 100644 src/agentex/types/agent_rpc_params1.py create mode 100644 src/agentex/types/agent_rpc_result.py create mode 100644 src/agentex/types/data_delta.py create mode 100644 src/agentex/types/shared/__init__.py create mode 100644 src/agentex/types/shared/task_message_update.py create mode 100644 src/agentex/types/task_message_content.py create mode 100644 src/agentex/types/task_message_content_param.py create mode 100644 src/agentex/types/task_message_delta.py create mode 100644 src/agentex/types/text_delta.py create mode 100644 src/agentex/types/tool_request_delta.py create mode 100644 src/agentex/types/tool_response_delta.py diff --git a/.stats.yml b/.stats.yml index e880ba66..3a087b17 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1d08fb2290b5310c91801d7575d356628d372fd5434e15d3b9cead48eadb893f.yml openapi_spec_hash: c07c588fb8429fbf024189df62f20fa4 -config_hash: 5a41a91d658dffbd60d617eb02e945f6 +config_hash: 2e4b423af3db79ebd8170c401ea9093a diff --git a/api.md b/api.md index 474200e1..f0754dd0 100644 --- a/api.md +++ b/api.md @@ -1,3 +1,9 @@ +# Shared Types + +```python +from agentex.types import TaskMessageUpdate +``` + # Agents Types: @@ -6,10 +12,18 @@ Types: from agentex.types import ( AcpType, Agent, + AgentRpcParams, AgentRpcRequest, - AgentListResponse, AgentRpcResponse, - AgentRpcByNameResponse, + AgentRpcResult, + DataDelta, + TaskMessageContent, + TaskMessageDelta, + TaskMessageUpdate, + TextDelta, + ToolRequestDelta, + ToolResponseDelta, + AgentListResponse, ) ``` @@ -21,7 +35,7 @@ Methods: - client.agents.delete_by_name(agent_name) -> Agent - client.agents.retrieve_by_name(agent_name) -> Agent - client.agents.rpc(agent_id, \*\*params) -> AgentRpcResponse -- client.agents.rpc_by_name(agent_name, \*\*params) -> AgentRpcByNameResponse +- client.agents.rpc_by_name(agent_name, \*\*params) -> AgentRpcResponse # Tasks diff --git a/src/agentex/resources/agents.py b/src/agentex/resources/agents.py index 3e5626c6..8b329be8 100644 --- a/src/agentex/resources/agents.py +++ b/src/agentex/resources/agents.py @@ -7,7 +7,7 @@ import httpx -from ..types import agent_rpc_params, agent_list_params, agent_rpc_by_name_params +from ..types import AgentRpcParams, agent_rpc_params, agent_list_params, agent_rpc_by_name_params from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property @@ -20,9 +20,9 @@ ) from ..types.agent import Agent from .._base_client import make_request_options +from ..types.agent_rpc_params import AgentRpcParams from ..types.agent_rpc_response import AgentRpcResponse from ..types.agent_list_response import AgentListResponse -from ..types.agent_rpc_by_name_response import AgentRpcByNameResponse __all__ = ["AgentsResource", "AsyncAgentsResource"] @@ -221,7 +221,7 @@ def rpc( agent_id: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_rpc_params.Params, + params: AgentRpcParams, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -269,7 +269,7 @@ def rpc_by_name( agent_name: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_rpc_by_name_params.Params, + params: AgentRpcParams, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -278,7 +278,7 @@ def rpc_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> AgentRpcByNameResponse: + ) -> AgentRpcResponse: """ Handle JSON-RPC requests for an agent by its unique name. @@ -309,7 +309,7 @@ def rpc_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AgentRpcByNameResponse, + cast_to=AgentRpcResponse, ) @@ -507,7 +507,7 @@ async def rpc( agent_id: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_rpc_params.Params, + params: AgentRpcParams, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -555,7 +555,7 @@ async def rpc_by_name( agent_name: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_rpc_by_name_params.Params, + params: AgentRpcParams, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -564,7 +564,7 @@ async def rpc_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> AgentRpcByNameResponse: + ) -> AgentRpcResponse: """ Handle JSON-RPC requests for an agent by its unique name. @@ -595,7 +595,7 @@ async def rpc_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AgentRpcByNameResponse, + cast_to=AgentRpcResponse, ) diff --git a/src/agentex/resources/messages/batch.py b/src/agentex/resources/messages/batch.py index 478c2df5..58412663 100644 --- a/src/agentex/resources/messages/batch.py +++ b/src/agentex/resources/messages/batch.py @@ -18,6 +18,7 @@ ) from ..._base_client import make_request_options from ...types.messages import batch_create_params, batch_update_params +from ...types.task_message_content_param import TaskMessageContentParam from ...types.messages.batch_create_response import BatchCreateResponse from ...types.messages.batch_update_response import BatchUpdateResponse @@ -47,7 +48,7 @@ def with_streaming_response(self) -> BatchResourceWithStreamingResponse: def create( self, *, - contents: Iterable[batch_create_params.Content], + contents: Iterable[TaskMessageContentParam], task_id: str, # 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. @@ -87,7 +88,7 @@ def update( self, *, task_id: str, - updates: Dict[str, batch_update_params.Updates], + updates: Dict[str, TaskMessageContentParam], # 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, @@ -146,7 +147,7 @@ def with_streaming_response(self) -> AsyncBatchResourceWithStreamingResponse: async def create( self, *, - contents: Iterable[batch_create_params.Content], + contents: Iterable[TaskMessageContentParam], task_id: str, # 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. @@ -186,7 +187,7 @@ async def update( self, *, task_id: str, - updates: Dict[str, batch_update_params.Updates], + updates: Dict[str, TaskMessageContentParam], # 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, diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index 2d83fb4e..b7f78c94 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -29,6 +29,7 @@ from ..._base_client import make_request_options from ...types.task_message import TaskMessage from ...types.message_list_response import MessageListResponse +from ...types.task_message_content_param import TaskMessageContentParam __all__ = ["MessagesResource", "AsyncMessagesResource"] @@ -60,7 +61,7 @@ def with_streaming_response(self) -> MessagesResourceWithStreamingResponse: def create( self, *, - content: message_create_params.Content, + content: TaskMessageContentParam, task_id: str, streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -135,7 +136,7 @@ def update( self, message_id: str, *, - content: message_update_params.Content, + content: TaskMessageContentParam, task_id: str, streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -245,7 +246,7 @@ def with_streaming_response(self) -> AsyncMessagesResourceWithStreamingResponse: async def create( self, *, - content: message_create_params.Content, + content: TaskMessageContentParam, task_id: str, streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -320,7 +321,7 @@ async def update( self, message_id: str, *, - content: message_update_params.Content, + content: TaskMessageContentParam, task_id: str, streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 5a380cdc..f021a20d 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -7,13 +7,17 @@ from .agent import Agent as Agent from .event import Event as Event from .state import State as State +from .shared import TaskMessageUpdate as TaskMessageUpdate from .acp_type import AcpType as AcpType +from .data_delta import DataDelta as DataDelta +from .text_delta import TextDelta as TextDelta from .data_content import DataContent as DataContent from .task_message import TaskMessage as TaskMessage from .text_content import TextContent as TextContent from .message_style import MessageStyle as MessageStyle from .message_author import MessageAuthor as MessageAuthor from .agent_rpc_params import AgentRpcParams as AgentRpcParams +from .agent_rpc_result import AgentRpcResult as AgentRpcResult from .span_list_params import SpanListParams as SpanListParams from .agent_list_params import AgentListParams as AgentListParams from .event_list_params import EventListParams as EventListParams @@ -25,14 +29,18 @@ from .span_list_response import SpanListResponse as SpanListResponse from .span_update_params import SpanUpdateParams as SpanUpdateParams from .task_list_response import TaskListResponse as TaskListResponse +from .task_message_delta import TaskMessageDelta as TaskMessageDelta from .text_content_param import TextContentParam as TextContentParam +from .tool_request_delta import ToolRequestDelta as ToolRequestDelta from .agent_list_response import AgentListResponse as AgentListResponse from .event_list_response import EventListResponse as EventListResponse from .message_list_params import MessageListParams as MessageListParams from .state_create_params import StateCreateParams as StateCreateParams from .state_list_response import StateListResponse as StateListResponse from .state_update_params import StateUpdateParams as StateUpdateParams +from .tool_response_delta import ToolResponseDelta as ToolResponseDelta from .tracker_list_params import TrackerListParams as TrackerListParams +from .task_message_content import TaskMessageContent as TaskMessageContent from .tool_request_content import ToolRequestContent as ToolRequestContent from .message_create_params import MessageCreateParams as MessageCreateParams from .message_list_response import MessageListResponse as MessageListResponse @@ -41,6 +49,6 @@ from .tracker_list_response import TrackerListResponse as TrackerListResponse from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams from .agent_rpc_by_name_params import AgentRpcByNameParams as AgentRpcByNameParams -from .agent_rpc_by_name_response import AgentRpcByNameResponse as AgentRpcByNameResponse +from .task_message_content_param import TaskMessageContentParam as TaskMessageContentParam from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam diff --git a/src/agentex/types/agent_rpc_by_name_params.py b/src/agentex/types/agent_rpc_by_name_params.py index 191081cc..5be189d7 100644 --- a/src/agentex/types/agent_rpc_by_name_params.py +++ b/src/agentex/types/agent_rpc_by_name_params.py @@ -2,85 +2,20 @@ from __future__ import annotations -from typing import Dict, Union, Optional -from typing_extensions import Literal, Required, TypeAlias, TypedDict +from typing import Union +from typing_extensions import Literal, Required, TypedDict -from .data_content_param import DataContentParam -from .text_content_param import TextContentParam -from .tool_request_content_param import ToolRequestContentParam -from .tool_response_content_param import ToolResponseContentParam +from .agent_rpc_params import AgentRpcParams -__all__ = [ - "AgentRpcByNameParams", - "Params", - "ParamsCreateTaskRequest", - "ParamsCancelTaskRequest", - "ParamsSendMessageRequest", - "ParamsSendMessageRequestContent", - "ParamsSendEventRequest", - "ParamsSendEventRequestContent", -] +__all__ = ["AgentRpcByNameParams"] class AgentRpcByNameParams(TypedDict, total=False): method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] - params: Required[Params] + params: Required[AgentRpcParams] """The parameters for the agent RPC request""" id: Union[int, str, None] jsonrpc: Literal["2.0"] - - -class ParamsCreateTaskRequest(TypedDict, total=False): - name: Optional[str] - """The name of the task to create""" - - params: Optional[Dict[str, object]] - """The parameters for the task""" - - -class ParamsCancelTaskRequest(TypedDict, total=False): - task_id: Optional[str] - """The ID of the task to cancel. Either this or task_name must be provided.""" - - task_name: Optional[str] - """The name of the task to cancel. Either this or task_id must be provided.""" - - -ParamsSendMessageRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendMessageRequest(TypedDict, total=False): - content: Required[ParamsSendMessageRequestContent] - """The message that was sent to the agent""" - - stream: bool - """Whether to stream the response message back to the client""" - - task_id: Optional[str] - """The ID of the task that the message was sent to""" - - -ParamsSendEventRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendEventRequest(TypedDict, total=False): - content: Optional[ParamsSendEventRequestContent] - """The content to send to the event""" - - task_id: Optional[str] - """The ID of the task that the event was sent to""" - - task_name: Optional[str] - """The name of the task that the event was sent to""" - - -Params: TypeAlias = Union[ - ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest -] diff --git a/src/agentex/types/agent_rpc_by_name_response.py b/src/agentex/types/agent_rpc_by_name_response.py deleted file mode 100644 index 05317965..00000000 --- a/src/agentex/types/agent_rpc_by_name_response.py +++ /dev/null @@ -1,165 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import List, Union, Optional -from typing_extensions import Literal, Annotated, TypeAlias - -from .task import Task -from .event import Event -from .._utils import PropertyInfo -from .._models import BaseModel -from .data_content import DataContent -from .task_message import TaskMessage -from .text_content import TextContent -from .tool_request_content import ToolRequestContent -from .tool_response_content import ToolResponseContent - -__all__ = [ - "AgentRpcByNameResponse", - "Result", - "ResultStreamTaskMessageStart", - "ResultStreamTaskMessageStartContent", - "ResultStreamTaskMessageDelta", - "ResultStreamTaskMessageDeltaDelta", - "ResultStreamTaskMessageDeltaDeltaTextDelta", - "ResultStreamTaskMessageDeltaDeltaDataDelta", - "ResultStreamTaskMessageDeltaDeltaToolRequestDelta", - "ResultStreamTaskMessageDeltaDeltaToolResponseDelta", - "ResultStreamTaskMessageFull", - "ResultStreamTaskMessageFullContent", - "ResultStreamTaskMessageDone", -] - -ResultStreamTaskMessageStartContent: TypeAlias = Annotated[ - Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") -] - - -class ResultStreamTaskMessageStart(BaseModel): - content: ResultStreamTaskMessageStartContent - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["start"]] = None - - -class ResultStreamTaskMessageDeltaDeltaTextDelta(BaseModel): - text_delta: Optional[str] = None - - type: Optional[Literal["text"]] = None - - -class ResultStreamTaskMessageDeltaDeltaDataDelta(BaseModel): - data_delta: Optional[str] = None - - type: Optional[Literal["data"]] = None - - -class ResultStreamTaskMessageDeltaDeltaToolRequestDelta(BaseModel): - name: str - - tool_call_id: str - - arguments_delta: Optional[str] = None - - type: Optional[Literal["tool_request"]] = None - - -class ResultStreamTaskMessageDeltaDeltaToolResponseDelta(BaseModel): - name: str - - tool_call_id: str - - content_delta: Optional[str] = None - - type: Optional[Literal["tool_response"]] = None - - -ResultStreamTaskMessageDeltaDelta: TypeAlias = Annotated[ - Union[ - ResultStreamTaskMessageDeltaDeltaTextDelta, - ResultStreamTaskMessageDeltaDeltaDataDelta, - ResultStreamTaskMessageDeltaDeltaToolRequestDelta, - ResultStreamTaskMessageDeltaDeltaToolResponseDelta, - None, - ], - PropertyInfo(discriminator="type"), -] - - -class ResultStreamTaskMessageDelta(BaseModel): - delta: Optional[ResultStreamTaskMessageDeltaDelta] = None - """Delta for text updates""" - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["delta"]] = None - - -ResultStreamTaskMessageFullContent: TypeAlias = Annotated[ - Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") -] - - -class ResultStreamTaskMessageFull(BaseModel): - content: ResultStreamTaskMessageFullContent - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["full"]] = None - - -class ResultStreamTaskMessageDone(BaseModel): - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["done"]] = None - - -Result: TypeAlias = Union[ - List[TaskMessage], - ResultStreamTaskMessageStart, - ResultStreamTaskMessageDelta, - ResultStreamTaskMessageFull, - ResultStreamTaskMessageDone, - Task, - Event, - None, -] - - -class AgentRpcByNameResponse(BaseModel): - result: Optional[Result] = None - """The result of the agent RPC request""" - - id: Union[int, str, None] = None - - error: Optional[object] = None - - jsonrpc: Optional[Literal["2.0"]] = None diff --git a/src/agentex/types/agent_rpc_params.py b/src/agentex/types/agent_rpc_params.py index 4e83e75f..5082b18c 100644 --- a/src/agentex/types/agent_rpc_params.py +++ b/src/agentex/types/agent_rpc_params.py @@ -3,37 +3,14 @@ from __future__ import annotations from typing import Dict, Union, Optional -from typing_extensions import Literal, Required, TypeAlias, TypedDict +from typing_extensions import Required, TypeAlias, TypedDict -from .data_content_param import DataContentParam -from .text_content_param import TextContentParam -from .tool_request_content_param import ToolRequestContentParam -from .tool_response_content_param import ToolResponseContentParam +from .task_message_content_param import TaskMessageContentParam -__all__ = [ - "AgentRpcParams", - "Params", - "ParamsCreateTaskRequest", - "ParamsCancelTaskRequest", - "ParamsSendMessageRequest", - "ParamsSendMessageRequestContent", - "ParamsSendEventRequest", - "ParamsSendEventRequestContent", -] +__all__ = ["AgentRpcParams", "CreateTaskRequest", "CancelTaskRequest", "SendMessageRequest", "SendEventRequest"] -class AgentRpcParams(TypedDict, total=False): - method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] - - params: Required[Params] - """The parameters for the agent RPC request""" - - id: Union[int, str, None] - - jsonrpc: Literal["2.0"] - - -class ParamsCreateTaskRequest(TypedDict, total=False): +class CreateTaskRequest(TypedDict, total=False): name: Optional[str] """The name of the task to create""" @@ -41,7 +18,7 @@ class ParamsCreateTaskRequest(TypedDict, total=False): """The parameters for the task""" -class ParamsCancelTaskRequest(TypedDict, total=False): +class CancelTaskRequest(TypedDict, total=False): task_id: Optional[str] """The ID of the task to cancel. Either this or task_name must be provided.""" @@ -49,13 +26,8 @@ class ParamsCancelTaskRequest(TypedDict, total=False): """The name of the task to cancel. Either this or task_id must be provided.""" -ParamsSendMessageRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendMessageRequest(TypedDict, total=False): - content: Required[ParamsSendMessageRequestContent] +class SendMessageRequest(TypedDict, total=False): + content: Required[TaskMessageContentParam] """The message that was sent to the agent""" stream: bool @@ -65,13 +37,8 @@ class ParamsSendMessageRequest(TypedDict, total=False): """The ID of the task that the message was sent to""" -ParamsSendEventRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendEventRequest(TypedDict, total=False): - content: Optional[ParamsSendEventRequestContent] +class SendEventRequest(TypedDict, total=False): + content: Optional[TaskMessageContentParam] """The content to send to the event""" task_id: Optional[str] @@ -81,6 +48,4 @@ class ParamsSendEventRequest(TypedDict, total=False): """The name of the task that the event was sent to""" -Params: TypeAlias = Union[ - ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest -] +AgentRpcParams: TypeAlias = Union[CreateTaskRequest, CancelTaskRequest, SendMessageRequest, SendEventRequest] diff --git a/src/agentex/types/agent_rpc_params1.py b/src/agentex/types/agent_rpc_params1.py new file mode 100644 index 00000000..3eae8b68 --- /dev/null +++ b/src/agentex/types/agent_rpc_params1.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union +from typing_extensions import Literal, Required, TypedDict + +from . import agent_rpc_params + +__all__ = ["AgentRpcParams"] + + +class AgentRpcParams(TypedDict, total=False): + method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] + + params: Required[agent_rpc_params.AgentRpcParams] + """The parameters for the agent RPC request""" + + id: Union[int, str, None] + + jsonrpc: Literal["2.0"] diff --git a/src/agentex/types/agent_rpc_response.py b/src/agentex/types/agent_rpc_response.py index f67a8152..e9995e80 100644 --- a/src/agentex/types/agent_rpc_response.py +++ b/src/agentex/types/agent_rpc_response.py @@ -1,161 +1,16 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import List, Union, Optional -from typing_extensions import Literal, Annotated, TypeAlias +from typing import Union, Optional +from typing_extensions import Literal -from .task import Task -from .event import Event -from .._utils import PropertyInfo from .._models import BaseModel -from .data_content import DataContent -from .task_message import TaskMessage -from .text_content import TextContent -from .tool_request_content import ToolRequestContent -from .tool_response_content import ToolResponseContent +from .agent_rpc_result import AgentRpcResult -__all__ = [ - "AgentRpcResponse", - "Result", - "ResultStreamTaskMessageStart", - "ResultStreamTaskMessageStartContent", - "ResultStreamTaskMessageDelta", - "ResultStreamTaskMessageDeltaDelta", - "ResultStreamTaskMessageDeltaDeltaTextDelta", - "ResultStreamTaskMessageDeltaDeltaDataDelta", - "ResultStreamTaskMessageDeltaDeltaToolRequestDelta", - "ResultStreamTaskMessageDeltaDeltaToolResponseDelta", - "ResultStreamTaskMessageFull", - "ResultStreamTaskMessageFullContent", - "ResultStreamTaskMessageDone", -] - -ResultStreamTaskMessageStartContent: TypeAlias = Annotated[ - Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") -] - - -class ResultStreamTaskMessageStart(BaseModel): - content: ResultStreamTaskMessageStartContent - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["start"]] = None - - -class ResultStreamTaskMessageDeltaDeltaTextDelta(BaseModel): - text_delta: Optional[str] = None - - type: Optional[Literal["text"]] = None - - -class ResultStreamTaskMessageDeltaDeltaDataDelta(BaseModel): - data_delta: Optional[str] = None - - type: Optional[Literal["data"]] = None - - -class ResultStreamTaskMessageDeltaDeltaToolRequestDelta(BaseModel): - name: str - - tool_call_id: str - - arguments_delta: Optional[str] = None - - type: Optional[Literal["tool_request"]] = None - - -class ResultStreamTaskMessageDeltaDeltaToolResponseDelta(BaseModel): - name: str - - tool_call_id: str - - content_delta: Optional[str] = None - - type: Optional[Literal["tool_response"]] = None - - -ResultStreamTaskMessageDeltaDelta: TypeAlias = Annotated[ - Union[ - ResultStreamTaskMessageDeltaDeltaTextDelta, - ResultStreamTaskMessageDeltaDeltaDataDelta, - ResultStreamTaskMessageDeltaDeltaToolRequestDelta, - ResultStreamTaskMessageDeltaDeltaToolResponseDelta, - None, - ], - PropertyInfo(discriminator="type"), -] - - -class ResultStreamTaskMessageDelta(BaseModel): - delta: Optional[ResultStreamTaskMessageDeltaDelta] = None - """Delta for text updates""" - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["delta"]] = None - - -ResultStreamTaskMessageFullContent: TypeAlias = Annotated[ - Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") -] - - -class ResultStreamTaskMessageFull(BaseModel): - content: ResultStreamTaskMessageFullContent - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["full"]] = None - - -class ResultStreamTaskMessageDone(BaseModel): - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["done"]] = None - - -Result: TypeAlias = Union[ - List[TaskMessage], - ResultStreamTaskMessageStart, - ResultStreamTaskMessageDelta, - ResultStreamTaskMessageFull, - ResultStreamTaskMessageDone, - Task, - Event, - None, -] +__all__ = ["AgentRpcResponse"] class AgentRpcResponse(BaseModel): - result: Optional[Result] = None + result: Optional[AgentRpcResult] = None """The result of the agent RPC request""" id: Union[int, str, None] = None diff --git a/src/agentex/types/agent_rpc_result.py b/src/agentex/types/agent_rpc_result.py new file mode 100644 index 00000000..63e30a5d --- /dev/null +++ b/src/agentex/types/agent_rpc_result.py @@ -0,0 +1,90 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Union, Optional +from typing_extensions import Literal, TypeAlias + +from .task import Task +from .event import Event +from .._models import BaseModel +from .task_message import TaskMessage +from .task_message_delta import TaskMessageDelta +from .task_message_content import TaskMessageContent + +__all__ = [ + "AgentRpcResult", + "StreamTaskMessageStart", + "StreamTaskMessageDelta", + "StreamTaskMessageFull", + "StreamTaskMessageDone", +] + + +class StreamTaskMessageStart(BaseModel): + content: TaskMessageContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["start"]] = None + + +class StreamTaskMessageDelta(BaseModel): + delta: Optional[TaskMessageDelta] = None + """Delta for text updates""" + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["delta"]] = None + + +class StreamTaskMessageFull(BaseModel): + content: TaskMessageContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["full"]] = None + + +class StreamTaskMessageDone(BaseModel): + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["done"]] = None + + +AgentRpcResult: TypeAlias = Union[ + List[TaskMessage], + StreamTaskMessageStart, + StreamTaskMessageDelta, + StreamTaskMessageFull, + StreamTaskMessageDone, + Task, + Event, + None, +] diff --git a/src/agentex/types/data_delta.py b/src/agentex/types/data_delta.py new file mode 100644 index 00000000..e30c12e7 --- /dev/null +++ b/src/agentex/types/data_delta.py @@ -0,0 +1,14 @@ +# 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__ = ["DataDelta"] + + +class DataDelta(BaseModel): + data_delta: Optional[str] = None + + type: Optional[Literal["data"]] = None diff --git a/src/agentex/types/event.py b/src/agentex/types/event.py index 3f1e5997..9a544cb6 100644 --- a/src/agentex/types/event.py +++ b/src/agentex/types/event.py @@ -1,21 +1,12 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Union, Optional +from typing import Optional from datetime import datetime -from typing_extensions import Annotated, TypeAlias -from .._utils import PropertyInfo from .._models import BaseModel -from .data_content import DataContent -from .text_content import TextContent -from .tool_request_content import ToolRequestContent -from .tool_response_content import ToolResponseContent +from .task_message_content import TaskMessageContent -__all__ = ["Event", "Content"] - -Content: TypeAlias = Annotated[ - Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent, None], PropertyInfo(discriminator="type") -] +__all__ = ["Event"] class Event(BaseModel): @@ -31,7 +22,7 @@ class Event(BaseModel): task_id: str """The UUID of the task that the event belongs to""" - content: Optional[Content] = None + content: Optional[TaskMessageContent] = None """The content of the event""" created_at: Optional[datetime] = None diff --git a/src/agentex/types/message_create_params.py b/src/agentex/types/message_create_params.py index 4d59ca07..787715ec 100644 --- a/src/agentex/types/message_create_params.py +++ b/src/agentex/types/message_create_params.py @@ -2,23 +2,17 @@ from __future__ import annotations -from typing import Union, Optional -from typing_extensions import Literal, Required, TypeAlias, TypedDict +from typing import Optional +from typing_extensions import Literal, Required, TypedDict -from .data_content_param import DataContentParam -from .text_content_param import TextContentParam -from .tool_request_content_param import ToolRequestContentParam -from .tool_response_content_param import ToolResponseContentParam +from .task_message_content_param import TaskMessageContentParam -__all__ = ["MessageCreateParams", "Content"] +__all__ = ["MessageCreateParams"] class MessageCreateParams(TypedDict, total=False): - content: Required[Content] + content: Required[TaskMessageContentParam] task_id: Required[str] streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] - - -Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex/types/message_update_params.py b/src/agentex/types/message_update_params.py index 08ce8478..ea3dbaf8 100644 --- a/src/agentex/types/message_update_params.py +++ b/src/agentex/types/message_update_params.py @@ -2,23 +2,17 @@ from __future__ import annotations -from typing import Union, Optional -from typing_extensions import Literal, Required, TypeAlias, TypedDict +from typing import Optional +from typing_extensions import Literal, Required, TypedDict -from .data_content_param import DataContentParam -from .text_content_param import TextContentParam -from .tool_request_content_param import ToolRequestContentParam -from .tool_response_content_param import ToolResponseContentParam +from .task_message_content_param import TaskMessageContentParam -__all__ = ["MessageUpdateParams", "Content"] +__all__ = ["MessageUpdateParams"] class MessageUpdateParams(TypedDict, total=False): - content: Required[Content] + content: Required[TaskMessageContentParam] task_id: Required[str] streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] - - -Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex/types/messages/batch_create_params.py b/src/agentex/types/messages/batch_create_params.py index c09c69a9..0a0153ae 100644 --- a/src/agentex/types/messages/batch_create_params.py +++ b/src/agentex/types/messages/batch_create_params.py @@ -2,21 +2,15 @@ from __future__ import annotations -from typing import Union, Iterable -from typing_extensions import Required, TypeAlias, TypedDict +from typing import Iterable +from typing_extensions import Required, TypedDict -from ..data_content_param import DataContentParam -from ..text_content_param import TextContentParam -from ..tool_request_content_param import ToolRequestContentParam -from ..tool_response_content_param import ToolResponseContentParam +from ..task_message_content_param import TaskMessageContentParam -__all__ = ["BatchCreateParams", "Content"] +__all__ = ["BatchCreateParams"] class BatchCreateParams(TypedDict, total=False): - contents: Required[Iterable[Content]] + contents: Required[Iterable[TaskMessageContentParam]] task_id: Required[str] - - -Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex/types/messages/batch_update_params.py b/src/agentex/types/messages/batch_update_params.py index 68f24f8d..c25e46f6 100644 --- a/src/agentex/types/messages/batch_update_params.py +++ b/src/agentex/types/messages/batch_update_params.py @@ -2,21 +2,15 @@ from __future__ import annotations -from typing import Dict, Union -from typing_extensions import Required, TypeAlias, TypedDict +from typing import Dict +from typing_extensions import Required, TypedDict -from ..data_content_param import DataContentParam -from ..text_content_param import TextContentParam -from ..tool_request_content_param import ToolRequestContentParam -from ..tool_response_content_param import ToolResponseContentParam +from ..task_message_content_param import TaskMessageContentParam -__all__ = ["BatchUpdateParams", "Updates"] +__all__ = ["BatchUpdateParams"] class BatchUpdateParams(TypedDict, total=False): task_id: Required[str] - updates: Required[Dict[str, Updates]] - - -Updates: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] + updates: Required[Dict[str, TaskMessageContentParam]] diff --git a/src/agentex/types/shared/__init__.py b/src/agentex/types/shared/__init__.py new file mode 100644 index 00000000..7b5a4954 --- /dev/null +++ b/src/agentex/types/shared/__init__.py @@ -0,0 +1,3 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .task_message_update import TaskMessageUpdate as TaskMessageUpdate diff --git a/src/agentex/types/shared/task_message_update.py b/src/agentex/types/shared/task_message_update.py new file mode 100644 index 00000000..cc01b598 --- /dev/null +++ b/src/agentex/types/shared/task_message_update.py @@ -0,0 +1,83 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Union, Optional +from typing_extensions import Literal, Annotated, TypeAlias + +from ..._utils import PropertyInfo +from ..._models import BaseModel +from ..task_message import TaskMessage +from ..task_message_delta import TaskMessageDelta +from ..task_message_content import TaskMessageContent + +__all__ = [ + "TaskMessageUpdate", + "StreamTaskMessageStart", + "StreamTaskMessageDelta", + "StreamTaskMessageFull", + "StreamTaskMessageDone", +] + + +class StreamTaskMessageStart(BaseModel): + content: TaskMessageContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["start"]] = None + + +class StreamTaskMessageDelta(BaseModel): + delta: Optional[TaskMessageDelta] = None + """Delta for text updates""" + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["delta"]] = None + + +class StreamTaskMessageFull(BaseModel): + content: TaskMessageContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["full"]] = None + + +class StreamTaskMessageDone(BaseModel): + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["done"]] = None + + +TaskMessageUpdate: TypeAlias = Annotated[ + Union[StreamTaskMessageStart, StreamTaskMessageDelta, StreamTaskMessageFull, StreamTaskMessageDone], + PropertyInfo(discriminator="type"), +] diff --git a/src/agentex/types/task_message.py b/src/agentex/types/task_message.py index 29adf4d3..b5938cc8 100644 --- a/src/agentex/types/task_message.py +++ b/src/agentex/types/task_message.py @@ -1,25 +1,17 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Union, Optional +from typing import Optional from datetime import datetime -from typing_extensions import Literal, Annotated, TypeAlias +from typing_extensions import Literal -from .._utils import PropertyInfo from .._models import BaseModel -from .data_content import DataContent -from .text_content import TextContent -from .tool_request_content import ToolRequestContent -from .tool_response_content import ToolResponseContent +from .task_message_content import TaskMessageContent -__all__ = ["TaskMessage", "Content"] - -Content: TypeAlias = Annotated[ - Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") -] +__all__ = ["TaskMessage"] class TaskMessage(BaseModel): - content: Content + content: TaskMessageContent """The content of the message. This content is not OpenAI compatible. These are messages that are meant to be diff --git a/src/agentex/types/task_message_content.py b/src/agentex/types/task_message_content.py new file mode 100644 index 00000000..126992b4 --- /dev/null +++ b/src/agentex/types/task_message_content.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Union +from typing_extensions import Annotated, TypeAlias + +from .._utils import PropertyInfo +from .data_content import DataContent +from .text_content import TextContent +from .tool_request_content import ToolRequestContent +from .tool_response_content import ToolResponseContent + +__all__ = ["TaskMessageContent"] + +TaskMessageContent: TypeAlias = Annotated[ + Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") +] diff --git a/src/agentex/types/task_message_content_param.py b/src/agentex/types/task_message_content_param.py new file mode 100644 index 00000000..6991c64e --- /dev/null +++ b/src/agentex/types/task_message_content_param.py @@ -0,0 +1,17 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union +from typing_extensions import TypeAlias + +from .data_content_param import DataContentParam +from .text_content_param import TextContentParam +from .tool_request_content_param import ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam + +__all__ = ["TaskMessageContentParam"] + +TaskMessageContentParam: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] diff --git a/src/agentex/types/task_message_delta.py b/src/agentex/types/task_message_delta.py new file mode 100644 index 00000000..5a477e5a --- /dev/null +++ b/src/agentex/types/task_message_delta.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Union +from typing_extensions import Annotated, TypeAlias + +from .._utils import PropertyInfo +from .data_delta import DataDelta +from .text_delta import TextDelta +from .tool_request_delta import ToolRequestDelta +from .tool_response_delta import ToolResponseDelta + +__all__ = ["TaskMessageDelta"] + +TaskMessageDelta: TypeAlias = Annotated[ + Union[TextDelta, DataDelta, ToolRequestDelta, ToolResponseDelta], PropertyInfo(discriminator="type") +] diff --git a/src/agentex/types/text_delta.py b/src/agentex/types/text_delta.py new file mode 100644 index 00000000..29a60cfd --- /dev/null +++ b/src/agentex/types/text_delta.py @@ -0,0 +1,14 @@ +# 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__ = ["TextDelta"] + + +class TextDelta(BaseModel): + text_delta: Optional[str] = None + + type: Optional[Literal["text"]] = None diff --git a/src/agentex/types/tool_request_delta.py b/src/agentex/types/tool_request_delta.py new file mode 100644 index 00000000..7877dfdd --- /dev/null +++ b/src/agentex/types/tool_request_delta.py @@ -0,0 +1,18 @@ +# 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__ = ["ToolRequestDelta"] + + +class ToolRequestDelta(BaseModel): + name: str + + tool_call_id: str + + arguments_delta: Optional[str] = None + + type: Optional[Literal["tool_request"]] = None diff --git a/src/agentex/types/tool_response_delta.py b/src/agentex/types/tool_response_delta.py new file mode 100644 index 00000000..383770db --- /dev/null +++ b/src/agentex/types/tool_response_delta.py @@ -0,0 +1,18 @@ +# 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__ = ["ToolResponseDelta"] + + +class ToolResponseDelta(BaseModel): + name: str + + tool_call_id: str + + content_delta: Optional[str] = None + + type: Optional[Literal["tool_response"]] = None diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index e415e011..7cb79375 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -13,7 +13,6 @@ Agent, AgentRpcResponse, AgentListResponse, - AgentRpcByNameResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -299,7 +298,7 @@ def test_method_rpc_by_name(self, client: Agentex) -> None: method="event/send", params={}, ) - assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -314,7 +313,7 @@ def test_method_rpc_by_name_with_all_params(self, client: Agentex) -> None: id=0, jsonrpc="2.0", ) - assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -328,7 +327,7 @@ def test_raw_response_rpc_by_name(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -342,7 +341,7 @@ def test_streaming_response_rpc_by_name(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -639,7 +638,7 @@ async def test_method_rpc_by_name(self, async_client: AsyncAgentex) -> None: method="event/send", params={}, ) - assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -654,7 +653,7 @@ async def test_method_rpc_by_name_with_all_params(self, async_client: AsyncAgent id=0, jsonrpc="2.0", ) - assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -668,7 +667,7 @@ async def test_raw_response_rpc_by_name(self, async_client: AsyncAgentex) -> Non assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -682,7 +681,7 @@ async def test_streaming_response_rpc_by_name(self, async_client: AsyncAgentex) assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AgentRpcByNameResponse, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True From 13d37b771e2becd598ddc028fddbcbe20f31d3de Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 23 Jul 2025 00:06:39 +0000 Subject: [PATCH 0035/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index b56c3d0b..e8285b71 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.1.0-alpha.4" + ".": "0.1.0-alpha.5" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 9fffbf82..29885d1d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex" -version = "0.1.0-alpha.4" +version = "0.1.0-alpha.5" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 756d68b8..6c4f3e31 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.1.0-alpha.4" # x-release-please-version +__version__ = "0.1.0-alpha.5" # x-release-please-version From 7ade43ea6d6fb7389f586bede8507fcffe715ac5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 23 Jul 2025 00:24:02 +0000 Subject: [PATCH 0036/1108] feat(api): api update --- .stats.yml | 4 +- api.md | 28 +----- src/agentex/resources/agents.py | 36 +++----- src/agentex/resources/messages/batch.py | 9 +- src/agentex/resources/messages/messages.py | 21 +++-- src/agentex/types/__init__.py | 11 +-- src/agentex/types/agent_rpc_by_name_params.py | 76 ++++++++++++++-- src/agentex/types/agent_rpc_params.py | 54 ++++++++--- src/agentex/types/agent_rpc_params1.py | 21 ----- src/agentex/types/agent_rpc_response.py | 20 ----- src/agentex/types/agent_rpc_result.py | 90 ------------------- src/agentex/types/data_delta.py | 14 --- src/agentex/types/event.py | 17 +++- src/agentex/types/message_create_params.py | 19 ++-- src/agentex/types/message_update_params.py | 19 ++-- .../types/messages/batch_create_params.py | 16 ++-- .../types/messages/batch_update_params.py | 16 ++-- src/agentex/types/shared/__init__.py | 3 - .../types/shared/task_message_update.py | 83 ----------------- src/agentex/types/streaming_status.py | 7 ++ src/agentex/types/task_message.py | 37 ++++---- src/agentex/types/task_message_content.py | 16 ---- .../types/task_message_content_param.py | 17 ---- src/agentex/types/task_message_delta.py | 16 ---- src/agentex/types/text_delta.py | 14 --- src/agentex/types/tool_request_delta.py | 18 ---- src/agentex/types/tool_response_delta.py | 18 ---- tests/api_resources/test_agents.py | 38 ++++---- 28 files changed, 253 insertions(+), 485 deletions(-) delete mode 100644 src/agentex/types/agent_rpc_params1.py delete mode 100644 src/agentex/types/agent_rpc_response.py delete mode 100644 src/agentex/types/agent_rpc_result.py delete mode 100644 src/agentex/types/data_delta.py delete mode 100644 src/agentex/types/shared/__init__.py delete mode 100644 src/agentex/types/shared/task_message_update.py create mode 100644 src/agentex/types/streaming_status.py delete mode 100644 src/agentex/types/task_message_content.py delete mode 100644 src/agentex/types/task_message_content_param.py delete mode 100644 src/agentex/types/task_message_delta.py delete mode 100644 src/agentex/types/text_delta.py delete mode 100644 src/agentex/types/tool_request_delta.py delete mode 100644 src/agentex/types/tool_response_delta.py diff --git a/.stats.yml b/.stats.yml index 3a087b17..9ea4b275 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1d08fb2290b5310c91801d7575d356628d372fd5434e15d3b9cead48eadb893f.yml -openapi_spec_hash: c07c588fb8429fbf024189df62f20fa4 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-021b55c88964b7a5bfc9d692d32a52c6b0150445656d2407c4cb8e9dd1e5f100.yml +openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 config_hash: 2e4b423af3db79ebd8170c401ea9093a diff --git a/api.md b/api.md index f0754dd0..8c2841ca 100644 --- a/api.md +++ b/api.md @@ -1,30 +1,9 @@ -# Shared Types - -```python -from agentex.types import TaskMessageUpdate -``` - # Agents Types: ```python -from agentex.types import ( - AcpType, - Agent, - AgentRpcParams, - AgentRpcRequest, - AgentRpcResponse, - AgentRpcResult, - DataDelta, - TaskMessageContent, - TaskMessageDelta, - TaskMessageUpdate, - TextDelta, - ToolRequestDelta, - ToolResponseDelta, - AgentListResponse, -) +from agentex.types import AcpType, Agent, AgentRpcRequest, AgentListResponse ``` Methods: @@ -34,8 +13,8 @@ Methods: - client.agents.delete(agent_id) -> Agent - client.agents.delete_by_name(agent_name) -> Agent - client.agents.retrieve_by_name(agent_name) -> Agent -- client.agents.rpc(agent_id, \*\*params) -> AgentRpcResponse -- client.agents.rpc_by_name(agent_name, \*\*params) -> AgentRpcResponse +- client.agents.rpc(agent_id, \*\*params) -> object +- client.agents.rpc_by_name(agent_name, \*\*params) -> object # Tasks @@ -64,6 +43,7 @@ from agentex.types import ( DataContent, MessageAuthor, MessageStyle, + StreamingStatus, TaskMessage, TextContent, ToolRequestContent, diff --git a/src/agentex/resources/agents.py b/src/agentex/resources/agents.py index 8b329be8..9c2e4bd5 100644 --- a/src/agentex/resources/agents.py +++ b/src/agentex/resources/agents.py @@ -7,7 +7,7 @@ import httpx -from ..types import AgentRpcParams, agent_rpc_params, agent_list_params, agent_rpc_by_name_params +from ..types import agent_rpc_params, agent_list_params, agent_rpc_by_name_params from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property @@ -20,8 +20,6 @@ ) from ..types.agent import Agent from .._base_client import make_request_options -from ..types.agent_rpc_params import AgentRpcParams -from ..types.agent_rpc_response import AgentRpcResponse from ..types.agent_list_response import AgentListResponse __all__ = ["AgentsResource", "AsyncAgentsResource"] @@ -221,7 +219,7 @@ def rpc( agent_id: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: AgentRpcParams, + params: agent_rpc_params.Params, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -230,13 +228,11 @@ def rpc( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> AgentRpcResponse: + ) -> object: """ Handle JSON-RPC requests for an agent by its unique ID. Args: - params: The parameters for the agent RPC request - extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -261,7 +257,7 @@ def rpc( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AgentRpcResponse, + cast_to=object, ) def rpc_by_name( @@ -269,7 +265,7 @@ def rpc_by_name( agent_name: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: AgentRpcParams, + params: agent_rpc_by_name_params.Params, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -278,13 +274,11 @@ def rpc_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> AgentRpcResponse: + ) -> object: """ Handle JSON-RPC requests for an agent by its unique name. Args: - params: The parameters for the agent RPC request - extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -309,7 +303,7 @@ def rpc_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AgentRpcResponse, + cast_to=object, ) @@ -507,7 +501,7 @@ async def rpc( agent_id: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: AgentRpcParams, + params: agent_rpc_params.Params, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -516,13 +510,11 @@ async def rpc( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> AgentRpcResponse: + ) -> object: """ Handle JSON-RPC requests for an agent by its unique ID. Args: - params: The parameters for the agent RPC request - extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -547,7 +539,7 @@ async def rpc( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AgentRpcResponse, + cast_to=object, ) async def rpc_by_name( @@ -555,7 +547,7 @@ async def rpc_by_name( agent_name: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: AgentRpcParams, + params: agent_rpc_by_name_params.Params, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -564,13 +556,11 @@ async def rpc_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> AgentRpcResponse: + ) -> object: """ Handle JSON-RPC requests for an agent by its unique name. Args: - params: The parameters for the agent RPC request - extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -595,7 +585,7 @@ async def rpc_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AgentRpcResponse, + cast_to=object, ) diff --git a/src/agentex/resources/messages/batch.py b/src/agentex/resources/messages/batch.py index 58412663..478c2df5 100644 --- a/src/agentex/resources/messages/batch.py +++ b/src/agentex/resources/messages/batch.py @@ -18,7 +18,6 @@ ) from ..._base_client import make_request_options from ...types.messages import batch_create_params, batch_update_params -from ...types.task_message_content_param import TaskMessageContentParam from ...types.messages.batch_create_response import BatchCreateResponse from ...types.messages.batch_update_response import BatchUpdateResponse @@ -48,7 +47,7 @@ def with_streaming_response(self) -> BatchResourceWithStreamingResponse: def create( self, *, - contents: Iterable[TaskMessageContentParam], + contents: Iterable[batch_create_params.Content], task_id: str, # 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. @@ -88,7 +87,7 @@ def update( self, *, task_id: str, - updates: Dict[str, TaskMessageContentParam], + updates: Dict[str, batch_update_params.Updates], # 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, @@ -147,7 +146,7 @@ def with_streaming_response(self) -> AsyncBatchResourceWithStreamingResponse: async def create( self, *, - contents: Iterable[TaskMessageContentParam], + contents: Iterable[batch_create_params.Content], task_id: str, # 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. @@ -187,7 +186,7 @@ async def update( self, *, task_id: str, - updates: Dict[str, TaskMessageContentParam], + updates: Dict[str, batch_update_params.Updates], # 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, diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index b7f78c94..7745cf76 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -3,7 +3,6 @@ from __future__ import annotations from typing import Optional -from typing_extensions import Literal import httpx @@ -15,7 +14,7 @@ BatchResourceWithStreamingResponse, AsyncBatchResourceWithStreamingResponse, ) -from ...types import message_list_params, message_create_params, message_update_params +from ...types import StreamingStatus, message_list_params, message_create_params, message_update_params from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property @@ -28,8 +27,8 @@ ) from ..._base_client import make_request_options from ...types.task_message import TaskMessage +from ...types.streaming_status import StreamingStatus from ...types.message_list_response import MessageListResponse -from ...types.task_message_content_param import TaskMessageContentParam __all__ = ["MessagesResource", "AsyncMessagesResource"] @@ -61,9 +60,9 @@ def with_streaming_response(self) -> MessagesResourceWithStreamingResponse: def create( self, *, - content: TaskMessageContentParam, + content: message_create_params.Content, task_id: str, - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, + streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, # 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, @@ -136,9 +135,9 @@ def update( self, message_id: str, *, - content: TaskMessageContentParam, + content: message_update_params.Content, task_id: str, - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, + streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, # 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, @@ -246,9 +245,9 @@ def with_streaming_response(self) -> AsyncMessagesResourceWithStreamingResponse: async def create( self, *, - content: TaskMessageContentParam, + content: message_create_params.Content, task_id: str, - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, + streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, # 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, @@ -321,9 +320,9 @@ async def update( self, message_id: str, *, - content: TaskMessageContentParam, + content: message_update_params.Content, task_id: str, - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, + streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, # 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, diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index f021a20d..a5e72143 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -7,40 +7,32 @@ from .agent import Agent as Agent from .event import Event as Event from .state import State as State -from .shared import TaskMessageUpdate as TaskMessageUpdate from .acp_type import AcpType as AcpType -from .data_delta import DataDelta as DataDelta -from .text_delta import TextDelta as TextDelta from .data_content import DataContent as DataContent from .task_message import TaskMessage as TaskMessage from .text_content import TextContent as TextContent from .message_style import MessageStyle as MessageStyle from .message_author import MessageAuthor as MessageAuthor from .agent_rpc_params import AgentRpcParams as AgentRpcParams -from .agent_rpc_result import AgentRpcResult as AgentRpcResult from .span_list_params import SpanListParams as SpanListParams +from .streaming_status import StreamingStatus as StreamingStatus from .agent_list_params import AgentListParams as AgentListParams from .event_list_params import EventListParams as EventListParams from .state_list_params import StateListParams as StateListParams -from .agent_rpc_response import AgentRpcResponse as AgentRpcResponse from .agent_task_tracker import AgentTaskTracker as AgentTaskTracker from .data_content_param import DataContentParam as DataContentParam from .span_create_params import SpanCreateParams as SpanCreateParams from .span_list_response import SpanListResponse as SpanListResponse from .span_update_params import SpanUpdateParams as SpanUpdateParams from .task_list_response import TaskListResponse as TaskListResponse -from .task_message_delta import TaskMessageDelta as TaskMessageDelta from .text_content_param import TextContentParam as TextContentParam -from .tool_request_delta import ToolRequestDelta as ToolRequestDelta from .agent_list_response import AgentListResponse as AgentListResponse from .event_list_response import EventListResponse as EventListResponse from .message_list_params import MessageListParams as MessageListParams from .state_create_params import StateCreateParams as StateCreateParams from .state_list_response import StateListResponse as StateListResponse from .state_update_params import StateUpdateParams as StateUpdateParams -from .tool_response_delta import ToolResponseDelta as ToolResponseDelta from .tracker_list_params import TrackerListParams as TrackerListParams -from .task_message_content import TaskMessageContent as TaskMessageContent from .tool_request_content import ToolRequestContent as ToolRequestContent from .message_create_params import MessageCreateParams as MessageCreateParams from .message_list_response import MessageListResponse as MessageListResponse @@ -49,6 +41,5 @@ from .tracker_list_response import TrackerListResponse as TrackerListResponse from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams from .agent_rpc_by_name_params import AgentRpcByNameParams as AgentRpcByNameParams -from .task_message_content_param import TaskMessageContentParam as TaskMessageContentParam from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam diff --git a/src/agentex/types/agent_rpc_by_name_params.py b/src/agentex/types/agent_rpc_by_name_params.py index 5be189d7..5014a076 100644 --- a/src/agentex/types/agent_rpc_by_name_params.py +++ b/src/agentex/types/agent_rpc_by_name_params.py @@ -2,20 +2,84 @@ from __future__ import annotations -from typing import Union -from typing_extensions import Literal, Required, TypedDict +from typing import Dict, Union, Optional +from typing_extensions import Literal, Required, TypeAlias, TypedDict -from .agent_rpc_params import AgentRpcParams +from .data_content_param import DataContentParam +from .text_content_param import TextContentParam +from .tool_request_content_param import ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam -__all__ = ["AgentRpcByNameParams"] +__all__ = [ + "AgentRpcByNameParams", + "Params", + "ParamsCreateTaskRequest", + "ParamsCancelTaskRequest", + "ParamsSendMessageRequest", + "ParamsSendMessageRequestContent", + "ParamsSendEventRequest", + "ParamsSendEventRequestContent", +] class AgentRpcByNameParams(TypedDict, total=False): method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] - params: Required[AgentRpcParams] - """The parameters for the agent RPC request""" + params: Required[Params] id: Union[int, str, None] jsonrpc: Literal["2.0"] + + +class ParamsCreateTaskRequest(TypedDict, total=False): + name: Optional[str] + """The name of the task to create""" + + params: Optional[Dict[str, object]] + """The parameters for the task""" + + +class ParamsCancelTaskRequest(TypedDict, total=False): + task_id: Optional[str] + """The ID of the task to cancel. Either this or task_name must be provided.""" + + task_name: Optional[str] + """The name of the task to cancel. Either this or task_id must be provided.""" + + +ParamsSendMessageRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendMessageRequest(TypedDict, total=False): + content: Required[ParamsSendMessageRequestContent] + """The message that was sent to the agent""" + + stream: bool + """Whether to stream the response message back to the client""" + + task_id: Optional[str] + """The ID of the task that the message was sent to""" + + +ParamsSendEventRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendEventRequest(TypedDict, total=False): + content: Optional[ParamsSendEventRequestContent] + """The content to send to the event""" + + task_id: Optional[str] + """The ID of the task that the event was sent to""" + + task_name: Optional[str] + """The name of the task that the event was sent to""" + + +Params: TypeAlias = Union[ + ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest +] diff --git a/src/agentex/types/agent_rpc_params.py b/src/agentex/types/agent_rpc_params.py index 5082b18c..2c79a7a9 100644 --- a/src/agentex/types/agent_rpc_params.py +++ b/src/agentex/types/agent_rpc_params.py @@ -3,14 +3,36 @@ from __future__ import annotations from typing import Dict, Union, Optional -from typing_extensions import Required, TypeAlias, TypedDict +from typing_extensions import Literal, Required, TypeAlias, TypedDict -from .task_message_content_param import TaskMessageContentParam +from .data_content_param import DataContentParam +from .text_content_param import TextContentParam +from .tool_request_content_param import ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam -__all__ = ["AgentRpcParams", "CreateTaskRequest", "CancelTaskRequest", "SendMessageRequest", "SendEventRequest"] +__all__ = [ + "AgentRpcParams", + "Params", + "ParamsCreateTaskRequest", + "ParamsCancelTaskRequest", + "ParamsSendMessageRequest", + "ParamsSendMessageRequestContent", + "ParamsSendEventRequest", + "ParamsSendEventRequestContent", +] -class CreateTaskRequest(TypedDict, total=False): +class AgentRpcParams(TypedDict, total=False): + method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] + + params: Required[Params] + + id: Union[int, str, None] + + jsonrpc: Literal["2.0"] + + +class ParamsCreateTaskRequest(TypedDict, total=False): name: Optional[str] """The name of the task to create""" @@ -18,7 +40,7 @@ class CreateTaskRequest(TypedDict, total=False): """The parameters for the task""" -class CancelTaskRequest(TypedDict, total=False): +class ParamsCancelTaskRequest(TypedDict, total=False): task_id: Optional[str] """The ID of the task to cancel. Either this or task_name must be provided.""" @@ -26,8 +48,13 @@ class CancelTaskRequest(TypedDict, total=False): """The name of the task to cancel. Either this or task_id must be provided.""" -class SendMessageRequest(TypedDict, total=False): - content: Required[TaskMessageContentParam] +ParamsSendMessageRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendMessageRequest(TypedDict, total=False): + content: Required[ParamsSendMessageRequestContent] """The message that was sent to the agent""" stream: bool @@ -37,8 +64,13 @@ class SendMessageRequest(TypedDict, total=False): """The ID of the task that the message was sent to""" -class SendEventRequest(TypedDict, total=False): - content: Optional[TaskMessageContentParam] +ParamsSendEventRequestContent: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] + + +class ParamsSendEventRequest(TypedDict, total=False): + content: Optional[ParamsSendEventRequestContent] """The content to send to the event""" task_id: Optional[str] @@ -48,4 +80,6 @@ class SendEventRequest(TypedDict, total=False): """The name of the task that the event was sent to""" -AgentRpcParams: TypeAlias = Union[CreateTaskRequest, CancelTaskRequest, SendMessageRequest, SendEventRequest] +Params: TypeAlias = Union[ + ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest +] diff --git a/src/agentex/types/agent_rpc_params1.py b/src/agentex/types/agent_rpc_params1.py deleted file mode 100644 index 3eae8b68..00000000 --- a/src/agentex/types/agent_rpc_params1.py +++ /dev/null @@ -1,21 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Union -from typing_extensions import Literal, Required, TypedDict - -from . import agent_rpc_params - -__all__ = ["AgentRpcParams"] - - -class AgentRpcParams(TypedDict, total=False): - method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] - - params: Required[agent_rpc_params.AgentRpcParams] - """The parameters for the agent RPC request""" - - id: Union[int, str, None] - - jsonrpc: Literal["2.0"] diff --git a/src/agentex/types/agent_rpc_response.py b/src/agentex/types/agent_rpc_response.py deleted file mode 100644 index e9995e80..00000000 --- a/src/agentex/types/agent_rpc_response.py +++ /dev/null @@ -1,20 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import Union, Optional -from typing_extensions import Literal - -from .._models import BaseModel -from .agent_rpc_result import AgentRpcResult - -__all__ = ["AgentRpcResponse"] - - -class AgentRpcResponse(BaseModel): - result: Optional[AgentRpcResult] = None - """The result of the agent RPC request""" - - id: Union[int, str, None] = None - - error: Optional[object] = None - - jsonrpc: Optional[Literal["2.0"]] = None diff --git a/src/agentex/types/agent_rpc_result.py b/src/agentex/types/agent_rpc_result.py deleted file mode 100644 index 63e30a5d..00000000 --- a/src/agentex/types/agent_rpc_result.py +++ /dev/null @@ -1,90 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import List, Union, Optional -from typing_extensions import Literal, TypeAlias - -from .task import Task -from .event import Event -from .._models import BaseModel -from .task_message import TaskMessage -from .task_message_delta import TaskMessageDelta -from .task_message_content import TaskMessageContent - -__all__ = [ - "AgentRpcResult", - "StreamTaskMessageStart", - "StreamTaskMessageDelta", - "StreamTaskMessageFull", - "StreamTaskMessageDone", -] - - -class StreamTaskMessageStart(BaseModel): - content: TaskMessageContent - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["start"]] = None - - -class StreamTaskMessageDelta(BaseModel): - delta: Optional[TaskMessageDelta] = None - """Delta for text updates""" - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["delta"]] = None - - -class StreamTaskMessageFull(BaseModel): - content: TaskMessageContent - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["full"]] = None - - -class StreamTaskMessageDone(BaseModel): - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["done"]] = None - - -AgentRpcResult: TypeAlias = Union[ - List[TaskMessage], - StreamTaskMessageStart, - StreamTaskMessageDelta, - StreamTaskMessageFull, - StreamTaskMessageDone, - Task, - Event, - None, -] diff --git a/src/agentex/types/data_delta.py b/src/agentex/types/data_delta.py deleted file mode 100644 index e30c12e7..00000000 --- a/src/agentex/types/data_delta.py +++ /dev/null @@ -1,14 +0,0 @@ -# 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__ = ["DataDelta"] - - -class DataDelta(BaseModel): - data_delta: Optional[str] = None - - type: Optional[Literal["data"]] = None diff --git a/src/agentex/types/event.py b/src/agentex/types/event.py index 9a544cb6..3f1e5997 100644 --- a/src/agentex/types/event.py +++ b/src/agentex/types/event.py @@ -1,12 +1,21 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Optional +from typing import Union, Optional from datetime import datetime +from typing_extensions import Annotated, TypeAlias +from .._utils import PropertyInfo from .._models import BaseModel -from .task_message_content import TaskMessageContent +from .data_content import DataContent +from .text_content import TextContent +from .tool_request_content import ToolRequestContent +from .tool_response_content import ToolResponseContent -__all__ = ["Event"] +__all__ = ["Event", "Content"] + +Content: TypeAlias = Annotated[ + Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent, None], PropertyInfo(discriminator="type") +] class Event(BaseModel): @@ -22,7 +31,7 @@ class Event(BaseModel): task_id: str """The UUID of the task that the event belongs to""" - content: Optional[TaskMessageContent] = None + content: Optional[Content] = None """The content of the event""" created_at: Optional[datetime] = None diff --git a/src/agentex/types/message_create_params.py b/src/agentex/types/message_create_params.py index 787715ec..06ec3727 100644 --- a/src/agentex/types/message_create_params.py +++ b/src/agentex/types/message_create_params.py @@ -2,17 +2,24 @@ from __future__ import annotations -from typing import Optional -from typing_extensions import Literal, Required, TypedDict +from typing import Union, Optional +from typing_extensions import Required, TypeAlias, TypedDict -from .task_message_content_param import TaskMessageContentParam +from .streaming_status import StreamingStatus +from .data_content_param import DataContentParam +from .text_content_param import TextContentParam +from .tool_request_content_param import ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam -__all__ = ["MessageCreateParams"] +__all__ = ["MessageCreateParams", "Content"] class MessageCreateParams(TypedDict, total=False): - content: Required[TaskMessageContentParam] + content: Required[Content] task_id: Required[str] - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] + streaming_status: Optional[StreamingStatus] + + +Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex/types/message_update_params.py b/src/agentex/types/message_update_params.py index ea3dbaf8..bc5305b8 100644 --- a/src/agentex/types/message_update_params.py +++ b/src/agentex/types/message_update_params.py @@ -2,17 +2,24 @@ from __future__ import annotations -from typing import Optional -from typing_extensions import Literal, Required, TypedDict +from typing import Union, Optional +from typing_extensions import Required, TypeAlias, TypedDict -from .task_message_content_param import TaskMessageContentParam +from .streaming_status import StreamingStatus +from .data_content_param import DataContentParam +from .text_content_param import TextContentParam +from .tool_request_content_param import ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam -__all__ = ["MessageUpdateParams"] +__all__ = ["MessageUpdateParams", "Content"] class MessageUpdateParams(TypedDict, total=False): - content: Required[TaskMessageContentParam] + content: Required[Content] task_id: Required[str] - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] + streaming_status: Optional[StreamingStatus] + + +Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex/types/messages/batch_create_params.py b/src/agentex/types/messages/batch_create_params.py index 0a0153ae..c09c69a9 100644 --- a/src/agentex/types/messages/batch_create_params.py +++ b/src/agentex/types/messages/batch_create_params.py @@ -2,15 +2,21 @@ from __future__ import annotations -from typing import Iterable -from typing_extensions import Required, TypedDict +from typing import Union, Iterable +from typing_extensions import Required, TypeAlias, TypedDict -from ..task_message_content_param import TaskMessageContentParam +from ..data_content_param import DataContentParam +from ..text_content_param import TextContentParam +from ..tool_request_content_param import ToolRequestContentParam +from ..tool_response_content_param import ToolResponseContentParam -__all__ = ["BatchCreateParams"] +__all__ = ["BatchCreateParams", "Content"] class BatchCreateParams(TypedDict, total=False): - contents: Required[Iterable[TaskMessageContentParam]] + contents: Required[Iterable[Content]] task_id: Required[str] + + +Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex/types/messages/batch_update_params.py b/src/agentex/types/messages/batch_update_params.py index c25e46f6..68f24f8d 100644 --- a/src/agentex/types/messages/batch_update_params.py +++ b/src/agentex/types/messages/batch_update_params.py @@ -2,15 +2,21 @@ from __future__ import annotations -from typing import Dict -from typing_extensions import Required, TypedDict +from typing import Dict, Union +from typing_extensions import Required, TypeAlias, TypedDict -from ..task_message_content_param import TaskMessageContentParam +from ..data_content_param import DataContentParam +from ..text_content_param import TextContentParam +from ..tool_request_content_param import ToolRequestContentParam +from ..tool_response_content_param import ToolResponseContentParam -__all__ = ["BatchUpdateParams"] +__all__ = ["BatchUpdateParams", "Updates"] class BatchUpdateParams(TypedDict, total=False): task_id: Required[str] - updates: Required[Dict[str, TaskMessageContentParam]] + updates: Required[Dict[str, Updates]] + + +Updates: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex/types/shared/__init__.py b/src/agentex/types/shared/__init__.py deleted file mode 100644 index 7b5a4954..00000000 --- a/src/agentex/types/shared/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .task_message_update import TaskMessageUpdate as TaskMessageUpdate diff --git a/src/agentex/types/shared/task_message_update.py b/src/agentex/types/shared/task_message_update.py deleted file mode 100644 index cc01b598..00000000 --- a/src/agentex/types/shared/task_message_update.py +++ /dev/null @@ -1,83 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import Union, Optional -from typing_extensions import Literal, Annotated, TypeAlias - -from ..._utils import PropertyInfo -from ..._models import BaseModel -from ..task_message import TaskMessage -from ..task_message_delta import TaskMessageDelta -from ..task_message_content import TaskMessageContent - -__all__ = [ - "TaskMessageUpdate", - "StreamTaskMessageStart", - "StreamTaskMessageDelta", - "StreamTaskMessageFull", - "StreamTaskMessageDone", -] - - -class StreamTaskMessageStart(BaseModel): - content: TaskMessageContent - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["start"]] = None - - -class StreamTaskMessageDelta(BaseModel): - delta: Optional[TaskMessageDelta] = None - """Delta for text updates""" - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["delta"]] = None - - -class StreamTaskMessageFull(BaseModel): - content: TaskMessageContent - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["full"]] = None - - -class StreamTaskMessageDone(BaseModel): - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["done"]] = None - - -TaskMessageUpdate: TypeAlias = Annotated[ - Union[StreamTaskMessageStart, StreamTaskMessageDelta, StreamTaskMessageFull, StreamTaskMessageDone], - PropertyInfo(discriminator="type"), -] diff --git a/src/agentex/types/streaming_status.py b/src/agentex/types/streaming_status.py new file mode 100644 index 00000000..196d7881 --- /dev/null +++ b/src/agentex/types/streaming_status.py @@ -0,0 +1,7 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing_extensions import Literal, TypeAlias + +__all__ = ["StreamingStatus"] + +StreamingStatus: TypeAlias = Literal["IN_PROGRESS", "DONE"] diff --git a/src/agentex/types/task_message.py b/src/agentex/types/task_message.py index b5938cc8..686ade7d 100644 --- a/src/agentex/types/task_message.py +++ b/src/agentex/types/task_message.py @@ -1,33 +1,36 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Optional +from typing import Union, Optional from datetime import datetime -from typing_extensions import Literal +from typing_extensions import Annotated, TypeAlias +from .._utils import PropertyInfo from .._models import BaseModel -from .task_message_content import TaskMessageContent +from .data_content import DataContent +from .text_content import TextContent +from .streaming_status import StreamingStatus +from .tool_request_content import ToolRequestContent +from .tool_response_content import ToolResponseContent -__all__ = ["TaskMessage"] +__all__ = ["TaskMessage", "Content"] +Content: TypeAlias = Annotated[ + Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") +] -class TaskMessage(BaseModel): - content: TaskMessageContent - """The content of the message. - - This content is not OpenAI compatible. These are messages that are meant to be - displayed to the user. - """ - - task_id: str - """ID of the task this message belongs to""" - id: Optional[str] = None +class TaskMessage(BaseModel): + id: str """The task message's unique id""" - created_at: Optional[datetime] = None + content: Content + + created_at: datetime """The timestamp when the message was created""" - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] = None + task_id: str + + streaming_status: Optional[StreamingStatus] = None updated_at: Optional[datetime] = None """The timestamp when the message was last updated""" diff --git a/src/agentex/types/task_message_content.py b/src/agentex/types/task_message_content.py deleted file mode 100644 index 126992b4..00000000 --- a/src/agentex/types/task_message_content.py +++ /dev/null @@ -1,16 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import Union -from typing_extensions import Annotated, TypeAlias - -from .._utils import PropertyInfo -from .data_content import DataContent -from .text_content import TextContent -from .tool_request_content import ToolRequestContent -from .tool_response_content import ToolResponseContent - -__all__ = ["TaskMessageContent"] - -TaskMessageContent: TypeAlias = Annotated[ - Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") -] diff --git a/src/agentex/types/task_message_content_param.py b/src/agentex/types/task_message_content_param.py deleted file mode 100644 index 6991c64e..00000000 --- a/src/agentex/types/task_message_content_param.py +++ /dev/null @@ -1,17 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Union -from typing_extensions import TypeAlias - -from .data_content_param import DataContentParam -from .text_content_param import TextContentParam -from .tool_request_content_param import ToolRequestContentParam -from .tool_response_content_param import ToolResponseContentParam - -__all__ = ["TaskMessageContentParam"] - -TaskMessageContentParam: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] diff --git a/src/agentex/types/task_message_delta.py b/src/agentex/types/task_message_delta.py deleted file mode 100644 index 5a477e5a..00000000 --- a/src/agentex/types/task_message_delta.py +++ /dev/null @@ -1,16 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import Union -from typing_extensions import Annotated, TypeAlias - -from .._utils import PropertyInfo -from .data_delta import DataDelta -from .text_delta import TextDelta -from .tool_request_delta import ToolRequestDelta -from .tool_response_delta import ToolResponseDelta - -__all__ = ["TaskMessageDelta"] - -TaskMessageDelta: TypeAlias = Annotated[ - Union[TextDelta, DataDelta, ToolRequestDelta, ToolResponseDelta], PropertyInfo(discriminator="type") -] diff --git a/src/agentex/types/text_delta.py b/src/agentex/types/text_delta.py deleted file mode 100644 index 29a60cfd..00000000 --- a/src/agentex/types/text_delta.py +++ /dev/null @@ -1,14 +0,0 @@ -# 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__ = ["TextDelta"] - - -class TextDelta(BaseModel): - text_delta: Optional[str] = None - - type: Optional[Literal["text"]] = None diff --git a/src/agentex/types/tool_request_delta.py b/src/agentex/types/tool_request_delta.py deleted file mode 100644 index 7877dfdd..00000000 --- a/src/agentex/types/tool_request_delta.py +++ /dev/null @@ -1,18 +0,0 @@ -# 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__ = ["ToolRequestDelta"] - - -class ToolRequestDelta(BaseModel): - name: str - - tool_call_id: str - - arguments_delta: Optional[str] = None - - type: Optional[Literal["tool_request"]] = None diff --git a/src/agentex/types/tool_response_delta.py b/src/agentex/types/tool_response_delta.py deleted file mode 100644 index 383770db..00000000 --- a/src/agentex/types/tool_response_delta.py +++ /dev/null @@ -1,18 +0,0 @@ -# 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__ = ["ToolResponseDelta"] - - -class ToolResponseDelta(BaseModel): - name: str - - tool_call_id: str - - content_delta: Optional[str] = None - - type: Optional[Literal["tool_response"]] = None diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index 7cb79375..b2819f31 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -9,11 +9,7 @@ from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type -from agentex.types import ( - Agent, - AgentRpcResponse, - AgentListResponse, -) +from agentex.types import Agent, AgentListResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -233,7 +229,7 @@ def test_method_rpc(self, client: Agentex) -> None: method="event/send", params={}, ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -248,7 +244,7 @@ def test_method_rpc_with_all_params(self, client: Agentex) -> None: id=0, jsonrpc="2.0", ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -262,7 +258,7 @@ def test_raw_response_rpc(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -276,7 +272,7 @@ def test_streaming_response_rpc(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -298,7 +294,7 @@ def test_method_rpc_by_name(self, client: Agentex) -> None: method="event/send", params={}, ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -313,7 +309,7 @@ def test_method_rpc_by_name_with_all_params(self, client: Agentex) -> None: id=0, jsonrpc="2.0", ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -327,7 +323,7 @@ def test_raw_response_rpc_by_name(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -341,7 +337,7 @@ def test_streaming_response_rpc_by_name(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -573,7 +569,7 @@ async def test_method_rpc(self, async_client: AsyncAgentex) -> None: method="event/send", params={}, ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -588,7 +584,7 @@ async def test_method_rpc_with_all_params(self, async_client: AsyncAgentex) -> N id=0, jsonrpc="2.0", ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -602,7 +598,7 @@ async def test_raw_response_rpc(self, async_client: AsyncAgentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -616,7 +612,7 @@ async def test_streaming_response_rpc(self, async_client: AsyncAgentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -638,7 +634,7 @@ async def test_method_rpc_by_name(self, async_client: AsyncAgentex) -> None: method="event/send", params={}, ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -653,7 +649,7 @@ async def test_method_rpc_by_name_with_all_params(self, async_client: AsyncAgent id=0, jsonrpc="2.0", ) - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -667,7 +663,7 @@ async def test_raw_response_rpc_by_name(self, async_client: AsyncAgentex) -> Non assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -681,7 +677,7 @@ async def test_streaming_response_rpc_by_name(self, async_client: AsyncAgentex) assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AgentRpcResponse, agent, path=["response"]) + assert_matches_type(object, agent, path=["response"]) assert cast(Any, response.is_closed) is True From a800e34336ccbcdaefcf205ab6b1be2d1aca6011 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 23 Jul 2025 18:24:12 +0000 Subject: [PATCH 0037/1108] feat(api): api update --- .stats.yml | 4 +- api.md | 34 +++++-- src/agentex/resources/agents.py | 36 +++++--- src/agentex/resources/messages/batch.py | 9 +- src/agentex/resources/messages/messages.py | 21 ++--- src/agentex/resources/tasks.py | 18 ++-- src/agentex/types/__init__.py | 13 ++- src/agentex/types/agent_rpc_by_name_params.py | 76 ++-------------- src/agentex/types/agent_rpc_params.py | 54 +++-------- src/agentex/types/agent_rpc_params1.py | 21 +++++ src/agentex/types/agent_rpc_response.py | 20 +++++ src/agentex/types/agent_rpc_result.py | 90 +++++++++++++++++++ src/agentex/types/data_delta.py | 14 +++ src/agentex/types/event.py | 17 +--- src/agentex/types/message_create_params.py | 19 ++-- src/agentex/types/message_update_params.py | 19 ++-- .../types/messages/batch_create_params.py | 16 ++-- .../types/messages/batch_update_params.py | 16 ++-- src/agentex/types/shared/__init__.py | 3 + .../types/shared/task_message_update.py | 83 +++++++++++++++++ src/agentex/types/streaming_status.py | 7 -- .../types/task_delete_by_name_response.py | 8 ++ src/agentex/types/task_delete_response.py | 8 ++ src/agentex/types/task_message.py | 37 ++++---- src/agentex/types/task_message_content.py | 16 ++++ .../types/task_message_content_param.py | 17 ++++ src/agentex/types/task_message_delta.py | 16 ++++ src/agentex/types/text_delta.py | 14 +++ src/agentex/types/tool_request_delta.py | 18 ++++ src/agentex/types/tool_response_delta.py | 18 ++++ tests/api_resources/test_agents.py | 38 ++++---- tests/api_resources/test_tasks.py | 26 +++--- 32 files changed, 529 insertions(+), 277 deletions(-) create mode 100644 src/agentex/types/agent_rpc_params1.py create mode 100644 src/agentex/types/agent_rpc_response.py create mode 100644 src/agentex/types/agent_rpc_result.py create mode 100644 src/agentex/types/data_delta.py create mode 100644 src/agentex/types/shared/__init__.py create mode 100644 src/agentex/types/shared/task_message_update.py delete mode 100644 src/agentex/types/streaming_status.py create mode 100644 src/agentex/types/task_delete_by_name_response.py create mode 100644 src/agentex/types/task_delete_response.py create mode 100644 src/agentex/types/task_message_content.py create mode 100644 src/agentex/types/task_message_content_param.py create mode 100644 src/agentex/types/task_message_delta.py create mode 100644 src/agentex/types/text_delta.py create mode 100644 src/agentex/types/tool_request_delta.py create mode 100644 src/agentex/types/tool_response_delta.py diff --git a/.stats.yml b/.stats.yml index 9ea4b275..a8d58116 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-021b55c88964b7a5bfc9d692d32a52c6b0150445656d2407c4cb8e9dd1e5f100.yml -openapi_spec_hash: ed92c0d5d6bed9cb5617f8a776ac42c9 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-62a09183a027c64707ad1b9d7a5ccc66c8abf3965e6075282cb5ab72f742a2b3.yml +openapi_spec_hash: 47f43703822077a82e2edf82d4b7e0e5 config_hash: 2e4b423af3db79ebd8170c401ea9093a diff --git a/api.md b/api.md index 8c2841ca..223b095e 100644 --- a/api.md +++ b/api.md @@ -1,9 +1,30 @@ +# Shared Types + +```python +from agentex.types import TaskMessageUpdate +``` + # Agents Types: ```python -from agentex.types import AcpType, Agent, AgentRpcRequest, AgentListResponse +from agentex.types import ( + AcpType, + Agent, + AgentRpcParams, + AgentRpcRequest, + AgentRpcResponse, + AgentRpcResult, + DataDelta, + TaskMessageContent, + TaskMessageDelta, + TaskMessageUpdate, + TextDelta, + ToolRequestDelta, + ToolResponseDelta, + AgentListResponse, +) ``` Methods: @@ -13,23 +34,23 @@ Methods: - client.agents.delete(agent_id) -> Agent - client.agents.delete_by_name(agent_name) -> Agent - client.agents.retrieve_by_name(agent_name) -> Agent -- client.agents.rpc(agent_id, \*\*params) -> object -- client.agents.rpc_by_name(agent_name, \*\*params) -> object +- client.agents.rpc(agent_id, \*\*params) -> AgentRpcResponse +- client.agents.rpc_by_name(agent_name, \*\*params) -> AgentRpcResponse # Tasks Types: ```python -from agentex.types import Task, TaskListResponse +from agentex.types import Task, TaskListResponse, TaskDeleteResponse, TaskDeleteByNameResponse ``` Methods: - client.tasks.retrieve(task_id) -> Task - client.tasks.list() -> TaskListResponse -- client.tasks.delete(task_id) -> Task -- client.tasks.delete_by_name(task_name) -> Task +- client.tasks.delete(task_id) -> TaskDeleteResponse +- client.tasks.delete_by_name(task_name) -> TaskDeleteByNameResponse - client.tasks.retrieve_by_name(task_name) -> Task - client.tasks.stream_events(task_id) -> object - client.tasks.stream_events_by_name(task_name) -> object @@ -43,7 +64,6 @@ from agentex.types import ( DataContent, MessageAuthor, MessageStyle, - StreamingStatus, TaskMessage, TextContent, ToolRequestContent, diff --git a/src/agentex/resources/agents.py b/src/agentex/resources/agents.py index 9c2e4bd5..8b329be8 100644 --- a/src/agentex/resources/agents.py +++ b/src/agentex/resources/agents.py @@ -7,7 +7,7 @@ import httpx -from ..types import agent_rpc_params, agent_list_params, agent_rpc_by_name_params +from ..types import AgentRpcParams, agent_rpc_params, agent_list_params, agent_rpc_by_name_params from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property @@ -20,6 +20,8 @@ ) from ..types.agent import Agent from .._base_client import make_request_options +from ..types.agent_rpc_params import AgentRpcParams +from ..types.agent_rpc_response import AgentRpcResponse from ..types.agent_list_response import AgentListResponse __all__ = ["AgentsResource", "AsyncAgentsResource"] @@ -219,7 +221,7 @@ def rpc( agent_id: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_rpc_params.Params, + params: AgentRpcParams, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -228,11 +230,13 @@ def rpc( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> object: + ) -> AgentRpcResponse: """ Handle JSON-RPC requests for an agent by its unique ID. Args: + params: The parameters for the agent RPC request + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -257,7 +261,7 @@ def rpc( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=object, + cast_to=AgentRpcResponse, ) def rpc_by_name( @@ -265,7 +269,7 @@ def rpc_by_name( agent_name: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_rpc_by_name_params.Params, + params: AgentRpcParams, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -274,11 +278,13 @@ def rpc_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> object: + ) -> AgentRpcResponse: """ Handle JSON-RPC requests for an agent by its unique name. Args: + params: The parameters for the agent RPC request + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -303,7 +309,7 @@ def rpc_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=object, + cast_to=AgentRpcResponse, ) @@ -501,7 +507,7 @@ async def rpc( agent_id: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_rpc_params.Params, + params: AgentRpcParams, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -510,11 +516,13 @@ async def rpc( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> object: + ) -> AgentRpcResponse: """ Handle JSON-RPC requests for an agent by its unique ID. Args: + params: The parameters for the agent RPC request + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -539,7 +547,7 @@ async def rpc( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=object, + cast_to=AgentRpcResponse, ) async def rpc_by_name( @@ -547,7 +555,7 @@ async def rpc_by_name( agent_name: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: agent_rpc_by_name_params.Params, + params: AgentRpcParams, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -556,11 +564,13 @@ async def rpc_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> object: + ) -> AgentRpcResponse: """ Handle JSON-RPC requests for an agent by its unique name. Args: + params: The parameters for the agent RPC request + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -585,7 +595,7 @@ async def rpc_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=object, + cast_to=AgentRpcResponse, ) diff --git a/src/agentex/resources/messages/batch.py b/src/agentex/resources/messages/batch.py index 478c2df5..58412663 100644 --- a/src/agentex/resources/messages/batch.py +++ b/src/agentex/resources/messages/batch.py @@ -18,6 +18,7 @@ ) from ..._base_client import make_request_options from ...types.messages import batch_create_params, batch_update_params +from ...types.task_message_content_param import TaskMessageContentParam from ...types.messages.batch_create_response import BatchCreateResponse from ...types.messages.batch_update_response import BatchUpdateResponse @@ -47,7 +48,7 @@ def with_streaming_response(self) -> BatchResourceWithStreamingResponse: def create( self, *, - contents: Iterable[batch_create_params.Content], + contents: Iterable[TaskMessageContentParam], task_id: str, # 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. @@ -87,7 +88,7 @@ def update( self, *, task_id: str, - updates: Dict[str, batch_update_params.Updates], + updates: Dict[str, TaskMessageContentParam], # 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, @@ -146,7 +147,7 @@ def with_streaming_response(self) -> AsyncBatchResourceWithStreamingResponse: async def create( self, *, - contents: Iterable[batch_create_params.Content], + contents: Iterable[TaskMessageContentParam], task_id: str, # 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. @@ -186,7 +187,7 @@ async def update( self, *, task_id: str, - updates: Dict[str, batch_update_params.Updates], + updates: Dict[str, TaskMessageContentParam], # 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, diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index 7745cf76..b7f78c94 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -3,6 +3,7 @@ from __future__ import annotations from typing import Optional +from typing_extensions import Literal import httpx @@ -14,7 +15,7 @@ BatchResourceWithStreamingResponse, AsyncBatchResourceWithStreamingResponse, ) -from ...types import StreamingStatus, message_list_params, message_create_params, message_update_params +from ...types import message_list_params, message_create_params, message_update_params from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property @@ -27,8 +28,8 @@ ) from ..._base_client import make_request_options from ...types.task_message import TaskMessage -from ...types.streaming_status import StreamingStatus from ...types.message_list_response import MessageListResponse +from ...types.task_message_content_param import TaskMessageContentParam __all__ = ["MessagesResource", "AsyncMessagesResource"] @@ -60,9 +61,9 @@ def with_streaming_response(self) -> MessagesResourceWithStreamingResponse: def create( self, *, - content: message_create_params.Content, + content: TaskMessageContentParam, task_id: str, - streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # 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, @@ -135,9 +136,9 @@ def update( self, message_id: str, *, - content: message_update_params.Content, + content: TaskMessageContentParam, task_id: str, - streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # 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, @@ -245,9 +246,9 @@ def with_streaming_response(self) -> AsyncMessagesResourceWithStreamingResponse: async def create( self, *, - content: message_create_params.Content, + content: TaskMessageContentParam, task_id: str, - streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # 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, @@ -320,9 +321,9 @@ async def update( self, message_id: str, *, - content: message_update_params.Content, + content: TaskMessageContentParam, task_id: str, - streaming_status: Optional[StreamingStatus] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, # 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, diff --git a/src/agentex/resources/tasks.py b/src/agentex/resources/tasks.py index 936ee66c..6c6ce9d0 100644 --- a/src/agentex/resources/tasks.py +++ b/src/agentex/resources/tasks.py @@ -17,6 +17,8 @@ from ..types.task import Task from .._base_client import make_request_options from ..types.task_list_response import TaskListResponse +from ..types.task_delete_response import TaskDeleteResponse +from ..types.task_delete_by_name_response import TaskDeleteByNameResponse __all__ = ["TasksResource", "AsyncTasksResource"] @@ -103,7 +105,7 @@ def delete( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Task: + ) -> TaskDeleteResponse: """ Delete a task by its unique ID. @@ -123,7 +125,7 @@ def delete( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Task, + cast_to=TaskDeleteResponse, ) def delete_by_name( @@ -136,7 +138,7 @@ def delete_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Task: + ) -> TaskDeleteByNameResponse: """ Delete a task by its unique name. @@ -156,7 +158,7 @@ def delete_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Task, + cast_to=TaskDeleteByNameResponse, ) def retrieve_by_name( @@ -345,7 +347,7 @@ async def delete( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Task: + ) -> TaskDeleteResponse: """ Delete a task by its unique ID. @@ -365,7 +367,7 @@ async def delete( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Task, + cast_to=TaskDeleteResponse, ) async def delete_by_name( @@ -378,7 +380,7 @@ async def delete_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Task: + ) -> TaskDeleteByNameResponse: """ Delete a task by its unique name. @@ -398,7 +400,7 @@ async def delete_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Task, + cast_to=TaskDeleteByNameResponse, ) async def retrieve_by_name( diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index a5e72143..5623fb8a 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -7,32 +7,41 @@ from .agent import Agent as Agent from .event import Event as Event from .state import State as State +from .shared import TaskMessageUpdate as TaskMessageUpdate from .acp_type import AcpType as AcpType +from .data_delta import DataDelta as DataDelta +from .text_delta import TextDelta as TextDelta from .data_content import DataContent as DataContent from .task_message import TaskMessage as TaskMessage from .text_content import TextContent as TextContent from .message_style import MessageStyle as MessageStyle from .message_author import MessageAuthor as MessageAuthor from .agent_rpc_params import AgentRpcParams as AgentRpcParams +from .agent_rpc_result import AgentRpcResult as AgentRpcResult from .span_list_params import SpanListParams as SpanListParams -from .streaming_status import StreamingStatus as StreamingStatus from .agent_list_params import AgentListParams as AgentListParams from .event_list_params import EventListParams as EventListParams from .state_list_params import StateListParams as StateListParams +from .agent_rpc_response import AgentRpcResponse as AgentRpcResponse from .agent_task_tracker import AgentTaskTracker as AgentTaskTracker from .data_content_param import DataContentParam as DataContentParam from .span_create_params import SpanCreateParams as SpanCreateParams from .span_list_response import SpanListResponse as SpanListResponse from .span_update_params import SpanUpdateParams as SpanUpdateParams from .task_list_response import TaskListResponse as TaskListResponse +from .task_message_delta import TaskMessageDelta as TaskMessageDelta from .text_content_param import TextContentParam as TextContentParam +from .tool_request_delta import ToolRequestDelta as ToolRequestDelta from .agent_list_response import AgentListResponse as AgentListResponse from .event_list_response import EventListResponse as EventListResponse from .message_list_params import MessageListParams as MessageListParams from .state_create_params import StateCreateParams as StateCreateParams from .state_list_response import StateListResponse as StateListResponse from .state_update_params import StateUpdateParams as StateUpdateParams +from .tool_response_delta import ToolResponseDelta as ToolResponseDelta from .tracker_list_params import TrackerListParams as TrackerListParams +from .task_delete_response import TaskDeleteResponse as TaskDeleteResponse +from .task_message_content import TaskMessageContent as TaskMessageContent from .tool_request_content import ToolRequestContent as ToolRequestContent from .message_create_params import MessageCreateParams as MessageCreateParams from .message_list_response import MessageListResponse as MessageListResponse @@ -41,5 +50,7 @@ from .tracker_list_response import TrackerListResponse as TrackerListResponse from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams from .agent_rpc_by_name_params import AgentRpcByNameParams as AgentRpcByNameParams +from .task_message_content_param import TaskMessageContentParam as TaskMessageContentParam from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam +from .task_delete_by_name_response import TaskDeleteByNameResponse as TaskDeleteByNameResponse diff --git a/src/agentex/types/agent_rpc_by_name_params.py b/src/agentex/types/agent_rpc_by_name_params.py index 5014a076..5be189d7 100644 --- a/src/agentex/types/agent_rpc_by_name_params.py +++ b/src/agentex/types/agent_rpc_by_name_params.py @@ -2,84 +2,20 @@ from __future__ import annotations -from typing import Dict, Union, Optional -from typing_extensions import Literal, Required, TypeAlias, TypedDict +from typing import Union +from typing_extensions import Literal, Required, TypedDict -from .data_content_param import DataContentParam -from .text_content_param import TextContentParam -from .tool_request_content_param import ToolRequestContentParam -from .tool_response_content_param import ToolResponseContentParam +from .agent_rpc_params import AgentRpcParams -__all__ = [ - "AgentRpcByNameParams", - "Params", - "ParamsCreateTaskRequest", - "ParamsCancelTaskRequest", - "ParamsSendMessageRequest", - "ParamsSendMessageRequestContent", - "ParamsSendEventRequest", - "ParamsSendEventRequestContent", -] +__all__ = ["AgentRpcByNameParams"] class AgentRpcByNameParams(TypedDict, total=False): method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] - params: Required[Params] + params: Required[AgentRpcParams] + """The parameters for the agent RPC request""" id: Union[int, str, None] jsonrpc: Literal["2.0"] - - -class ParamsCreateTaskRequest(TypedDict, total=False): - name: Optional[str] - """The name of the task to create""" - - params: Optional[Dict[str, object]] - """The parameters for the task""" - - -class ParamsCancelTaskRequest(TypedDict, total=False): - task_id: Optional[str] - """The ID of the task to cancel. Either this or task_name must be provided.""" - - task_name: Optional[str] - """The name of the task to cancel. Either this or task_id must be provided.""" - - -ParamsSendMessageRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendMessageRequest(TypedDict, total=False): - content: Required[ParamsSendMessageRequestContent] - """The message that was sent to the agent""" - - stream: bool - """Whether to stream the response message back to the client""" - - task_id: Optional[str] - """The ID of the task that the message was sent to""" - - -ParamsSendEventRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendEventRequest(TypedDict, total=False): - content: Optional[ParamsSendEventRequestContent] - """The content to send to the event""" - - task_id: Optional[str] - """The ID of the task that the event was sent to""" - - task_name: Optional[str] - """The name of the task that the event was sent to""" - - -Params: TypeAlias = Union[ - ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest -] diff --git a/src/agentex/types/agent_rpc_params.py b/src/agentex/types/agent_rpc_params.py index 2c79a7a9..5082b18c 100644 --- a/src/agentex/types/agent_rpc_params.py +++ b/src/agentex/types/agent_rpc_params.py @@ -3,36 +3,14 @@ from __future__ import annotations from typing import Dict, Union, Optional -from typing_extensions import Literal, Required, TypeAlias, TypedDict +from typing_extensions import Required, TypeAlias, TypedDict -from .data_content_param import DataContentParam -from .text_content_param import TextContentParam -from .tool_request_content_param import ToolRequestContentParam -from .tool_response_content_param import ToolResponseContentParam +from .task_message_content_param import TaskMessageContentParam -__all__ = [ - "AgentRpcParams", - "Params", - "ParamsCreateTaskRequest", - "ParamsCancelTaskRequest", - "ParamsSendMessageRequest", - "ParamsSendMessageRequestContent", - "ParamsSendEventRequest", - "ParamsSendEventRequestContent", -] +__all__ = ["AgentRpcParams", "CreateTaskRequest", "CancelTaskRequest", "SendMessageRequest", "SendEventRequest"] -class AgentRpcParams(TypedDict, total=False): - method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] - - params: Required[Params] - - id: Union[int, str, None] - - jsonrpc: Literal["2.0"] - - -class ParamsCreateTaskRequest(TypedDict, total=False): +class CreateTaskRequest(TypedDict, total=False): name: Optional[str] """The name of the task to create""" @@ -40,7 +18,7 @@ class ParamsCreateTaskRequest(TypedDict, total=False): """The parameters for the task""" -class ParamsCancelTaskRequest(TypedDict, total=False): +class CancelTaskRequest(TypedDict, total=False): task_id: Optional[str] """The ID of the task to cancel. Either this or task_name must be provided.""" @@ -48,13 +26,8 @@ class ParamsCancelTaskRequest(TypedDict, total=False): """The name of the task to cancel. Either this or task_id must be provided.""" -ParamsSendMessageRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendMessageRequest(TypedDict, total=False): - content: Required[ParamsSendMessageRequestContent] +class SendMessageRequest(TypedDict, total=False): + content: Required[TaskMessageContentParam] """The message that was sent to the agent""" stream: bool @@ -64,13 +37,8 @@ class ParamsSendMessageRequest(TypedDict, total=False): """The ID of the task that the message was sent to""" -ParamsSendEventRequestContent: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam -] - - -class ParamsSendEventRequest(TypedDict, total=False): - content: Optional[ParamsSendEventRequestContent] +class SendEventRequest(TypedDict, total=False): + content: Optional[TaskMessageContentParam] """The content to send to the event""" task_id: Optional[str] @@ -80,6 +48,4 @@ class ParamsSendEventRequest(TypedDict, total=False): """The name of the task that the event was sent to""" -Params: TypeAlias = Union[ - ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest -] +AgentRpcParams: TypeAlias = Union[CreateTaskRequest, CancelTaskRequest, SendMessageRequest, SendEventRequest] diff --git a/src/agentex/types/agent_rpc_params1.py b/src/agentex/types/agent_rpc_params1.py new file mode 100644 index 00000000..3eae8b68 --- /dev/null +++ b/src/agentex/types/agent_rpc_params1.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union +from typing_extensions import Literal, Required, TypedDict + +from . import agent_rpc_params + +__all__ = ["AgentRpcParams"] + + +class AgentRpcParams(TypedDict, total=False): + method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] + + params: Required[agent_rpc_params.AgentRpcParams] + """The parameters for the agent RPC request""" + + id: Union[int, str, None] + + jsonrpc: Literal["2.0"] diff --git a/src/agentex/types/agent_rpc_response.py b/src/agentex/types/agent_rpc_response.py new file mode 100644 index 00000000..e9995e80 --- /dev/null +++ b/src/agentex/types/agent_rpc_response.py @@ -0,0 +1,20 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Union, Optional +from typing_extensions import Literal + +from .._models import BaseModel +from .agent_rpc_result import AgentRpcResult + +__all__ = ["AgentRpcResponse"] + + +class AgentRpcResponse(BaseModel): + result: Optional[AgentRpcResult] = None + """The result of the agent RPC request""" + + id: Union[int, str, None] = None + + error: Optional[object] = None + + jsonrpc: Optional[Literal["2.0"]] = None diff --git a/src/agentex/types/agent_rpc_result.py b/src/agentex/types/agent_rpc_result.py new file mode 100644 index 00000000..63e30a5d --- /dev/null +++ b/src/agentex/types/agent_rpc_result.py @@ -0,0 +1,90 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Union, Optional +from typing_extensions import Literal, TypeAlias + +from .task import Task +from .event import Event +from .._models import BaseModel +from .task_message import TaskMessage +from .task_message_delta import TaskMessageDelta +from .task_message_content import TaskMessageContent + +__all__ = [ + "AgentRpcResult", + "StreamTaskMessageStart", + "StreamTaskMessageDelta", + "StreamTaskMessageFull", + "StreamTaskMessageDone", +] + + +class StreamTaskMessageStart(BaseModel): + content: TaskMessageContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["start"]] = None + + +class StreamTaskMessageDelta(BaseModel): + delta: Optional[TaskMessageDelta] = None + """Delta for text updates""" + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["delta"]] = None + + +class StreamTaskMessageFull(BaseModel): + content: TaskMessageContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["full"]] = None + + +class StreamTaskMessageDone(BaseModel): + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["done"]] = None + + +AgentRpcResult: TypeAlias = Union[ + List[TaskMessage], + StreamTaskMessageStart, + StreamTaskMessageDelta, + StreamTaskMessageFull, + StreamTaskMessageDone, + Task, + Event, + None, +] diff --git a/src/agentex/types/data_delta.py b/src/agentex/types/data_delta.py new file mode 100644 index 00000000..e30c12e7 --- /dev/null +++ b/src/agentex/types/data_delta.py @@ -0,0 +1,14 @@ +# 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__ = ["DataDelta"] + + +class DataDelta(BaseModel): + data_delta: Optional[str] = None + + type: Optional[Literal["data"]] = None diff --git a/src/agentex/types/event.py b/src/agentex/types/event.py index 3f1e5997..9a544cb6 100644 --- a/src/agentex/types/event.py +++ b/src/agentex/types/event.py @@ -1,21 +1,12 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Union, Optional +from typing import Optional from datetime import datetime -from typing_extensions import Annotated, TypeAlias -from .._utils import PropertyInfo from .._models import BaseModel -from .data_content import DataContent -from .text_content import TextContent -from .tool_request_content import ToolRequestContent -from .tool_response_content import ToolResponseContent +from .task_message_content import TaskMessageContent -__all__ = ["Event", "Content"] - -Content: TypeAlias = Annotated[ - Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent, None], PropertyInfo(discriminator="type") -] +__all__ = ["Event"] class Event(BaseModel): @@ -31,7 +22,7 @@ class Event(BaseModel): task_id: str """The UUID of the task that the event belongs to""" - content: Optional[Content] = None + content: Optional[TaskMessageContent] = None """The content of the event""" created_at: Optional[datetime] = None diff --git a/src/agentex/types/message_create_params.py b/src/agentex/types/message_create_params.py index 06ec3727..787715ec 100644 --- a/src/agentex/types/message_create_params.py +++ b/src/agentex/types/message_create_params.py @@ -2,24 +2,17 @@ from __future__ import annotations -from typing import Union, Optional -from typing_extensions import Required, TypeAlias, TypedDict +from typing import Optional +from typing_extensions import Literal, Required, TypedDict -from .streaming_status import StreamingStatus -from .data_content_param import DataContentParam -from .text_content_param import TextContentParam -from .tool_request_content_param import ToolRequestContentParam -from .tool_response_content_param import ToolResponseContentParam +from .task_message_content_param import TaskMessageContentParam -__all__ = ["MessageCreateParams", "Content"] +__all__ = ["MessageCreateParams"] class MessageCreateParams(TypedDict, total=False): - content: Required[Content] + content: Required[TaskMessageContentParam] task_id: Required[str] - streaming_status: Optional[StreamingStatus] - - -Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] diff --git a/src/agentex/types/message_update_params.py b/src/agentex/types/message_update_params.py index bc5305b8..ea3dbaf8 100644 --- a/src/agentex/types/message_update_params.py +++ b/src/agentex/types/message_update_params.py @@ -2,24 +2,17 @@ from __future__ import annotations -from typing import Union, Optional -from typing_extensions import Required, TypeAlias, TypedDict +from typing import Optional +from typing_extensions import Literal, Required, TypedDict -from .streaming_status import StreamingStatus -from .data_content_param import DataContentParam -from .text_content_param import TextContentParam -from .tool_request_content_param import ToolRequestContentParam -from .tool_response_content_param import ToolResponseContentParam +from .task_message_content_param import TaskMessageContentParam -__all__ = ["MessageUpdateParams", "Content"] +__all__ = ["MessageUpdateParams"] class MessageUpdateParams(TypedDict, total=False): - content: Required[Content] + content: Required[TaskMessageContentParam] task_id: Required[str] - streaming_status: Optional[StreamingStatus] - - -Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] diff --git a/src/agentex/types/messages/batch_create_params.py b/src/agentex/types/messages/batch_create_params.py index c09c69a9..0a0153ae 100644 --- a/src/agentex/types/messages/batch_create_params.py +++ b/src/agentex/types/messages/batch_create_params.py @@ -2,21 +2,15 @@ from __future__ import annotations -from typing import Union, Iterable -from typing_extensions import Required, TypeAlias, TypedDict +from typing import Iterable +from typing_extensions import Required, TypedDict -from ..data_content_param import DataContentParam -from ..text_content_param import TextContentParam -from ..tool_request_content_param import ToolRequestContentParam -from ..tool_response_content_param import ToolResponseContentParam +from ..task_message_content_param import TaskMessageContentParam -__all__ = ["BatchCreateParams", "Content"] +__all__ = ["BatchCreateParams"] class BatchCreateParams(TypedDict, total=False): - contents: Required[Iterable[Content]] + contents: Required[Iterable[TaskMessageContentParam]] task_id: Required[str] - - -Content: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] diff --git a/src/agentex/types/messages/batch_update_params.py b/src/agentex/types/messages/batch_update_params.py index 68f24f8d..c25e46f6 100644 --- a/src/agentex/types/messages/batch_update_params.py +++ b/src/agentex/types/messages/batch_update_params.py @@ -2,21 +2,15 @@ from __future__ import annotations -from typing import Dict, Union -from typing_extensions import Required, TypeAlias, TypedDict +from typing import Dict +from typing_extensions import Required, TypedDict -from ..data_content_param import DataContentParam -from ..text_content_param import TextContentParam -from ..tool_request_content_param import ToolRequestContentParam -from ..tool_response_content_param import ToolResponseContentParam +from ..task_message_content_param import TaskMessageContentParam -__all__ = ["BatchUpdateParams", "Updates"] +__all__ = ["BatchUpdateParams"] class BatchUpdateParams(TypedDict, total=False): task_id: Required[str] - updates: Required[Dict[str, Updates]] - - -Updates: TypeAlias = Union[TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam] + updates: Required[Dict[str, TaskMessageContentParam]] diff --git a/src/agentex/types/shared/__init__.py b/src/agentex/types/shared/__init__.py new file mode 100644 index 00000000..7b5a4954 --- /dev/null +++ b/src/agentex/types/shared/__init__.py @@ -0,0 +1,3 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .task_message_update import TaskMessageUpdate as TaskMessageUpdate diff --git a/src/agentex/types/shared/task_message_update.py b/src/agentex/types/shared/task_message_update.py new file mode 100644 index 00000000..cc01b598 --- /dev/null +++ b/src/agentex/types/shared/task_message_update.py @@ -0,0 +1,83 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Union, Optional +from typing_extensions import Literal, Annotated, TypeAlias + +from ..._utils import PropertyInfo +from ..._models import BaseModel +from ..task_message import TaskMessage +from ..task_message_delta import TaskMessageDelta +from ..task_message_content import TaskMessageContent + +__all__ = [ + "TaskMessageUpdate", + "StreamTaskMessageStart", + "StreamTaskMessageDelta", + "StreamTaskMessageFull", + "StreamTaskMessageDone", +] + + +class StreamTaskMessageStart(BaseModel): + content: TaskMessageContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["start"]] = None + + +class StreamTaskMessageDelta(BaseModel): + delta: Optional[TaskMessageDelta] = None + """Delta for text updates""" + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["delta"]] = None + + +class StreamTaskMessageFull(BaseModel): + content: TaskMessageContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["full"]] = None + + +class StreamTaskMessageDone(BaseModel): + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["done"]] = None + + +TaskMessageUpdate: TypeAlias = Annotated[ + Union[StreamTaskMessageStart, StreamTaskMessageDelta, StreamTaskMessageFull, StreamTaskMessageDone], + PropertyInfo(discriminator="type"), +] diff --git a/src/agentex/types/streaming_status.py b/src/agentex/types/streaming_status.py deleted file mode 100644 index 196d7881..00000000 --- a/src/agentex/types/streaming_status.py +++ /dev/null @@ -1,7 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing_extensions import Literal, TypeAlias - -__all__ = ["StreamingStatus"] - -StreamingStatus: TypeAlias = Literal["IN_PROGRESS", "DONE"] diff --git a/src/agentex/types/task_delete_by_name_response.py b/src/agentex/types/task_delete_by_name_response.py new file mode 100644 index 00000000..bea61633 --- /dev/null +++ b/src/agentex/types/task_delete_by_name_response.py @@ -0,0 +1,8 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict +from typing_extensions import TypeAlias + +__all__ = ["TaskDeleteByNameResponse"] + +TaskDeleteByNameResponse: TypeAlias = Dict[str, str] diff --git a/src/agentex/types/task_delete_response.py b/src/agentex/types/task_delete_response.py new file mode 100644 index 00000000..62104057 --- /dev/null +++ b/src/agentex/types/task_delete_response.py @@ -0,0 +1,8 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict +from typing_extensions import TypeAlias + +__all__ = ["TaskDeleteResponse"] + +TaskDeleteResponse: TypeAlias = Dict[str, str] diff --git a/src/agentex/types/task_message.py b/src/agentex/types/task_message.py index 686ade7d..b5938cc8 100644 --- a/src/agentex/types/task_message.py +++ b/src/agentex/types/task_message.py @@ -1,36 +1,33 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Union, Optional +from typing import Optional from datetime import datetime -from typing_extensions import Annotated, TypeAlias +from typing_extensions import Literal -from .._utils import PropertyInfo from .._models import BaseModel -from .data_content import DataContent -from .text_content import TextContent -from .streaming_status import StreamingStatus -from .tool_request_content import ToolRequestContent -from .tool_response_content import ToolResponseContent +from .task_message_content import TaskMessageContent -__all__ = ["TaskMessage", "Content"] - -Content: TypeAlias = Annotated[ - Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") -] +__all__ = ["TaskMessage"] class TaskMessage(BaseModel): - id: str - """The task message's unique id""" + content: TaskMessageContent + """The content of the message. - content: Content - - created_at: datetime - """The timestamp when the message was created""" + This content is not OpenAI compatible. These are messages that are meant to be + displayed to the user. + """ task_id: str + """ID of the task this message belongs to""" + + id: Optional[str] = None + """The task message's unique id""" + + created_at: Optional[datetime] = None + """The timestamp when the message was created""" - streaming_status: Optional[StreamingStatus] = None + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] = None updated_at: Optional[datetime] = None """The timestamp when the message was last updated""" diff --git a/src/agentex/types/task_message_content.py b/src/agentex/types/task_message_content.py new file mode 100644 index 00000000..126992b4 --- /dev/null +++ b/src/agentex/types/task_message_content.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Union +from typing_extensions import Annotated, TypeAlias + +from .._utils import PropertyInfo +from .data_content import DataContent +from .text_content import TextContent +from .tool_request_content import ToolRequestContent +from .tool_response_content import ToolResponseContent + +__all__ = ["TaskMessageContent"] + +TaskMessageContent: TypeAlias = Annotated[ + Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") +] diff --git a/src/agentex/types/task_message_content_param.py b/src/agentex/types/task_message_content_param.py new file mode 100644 index 00000000..6991c64e --- /dev/null +++ b/src/agentex/types/task_message_content_param.py @@ -0,0 +1,17 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union +from typing_extensions import TypeAlias + +from .data_content_param import DataContentParam +from .text_content_param import TextContentParam +from .tool_request_content_param import ToolRequestContentParam +from .tool_response_content_param import ToolResponseContentParam + +__all__ = ["TaskMessageContentParam"] + +TaskMessageContentParam: TypeAlias = Union[ + TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam +] diff --git a/src/agentex/types/task_message_delta.py b/src/agentex/types/task_message_delta.py new file mode 100644 index 00000000..5a477e5a --- /dev/null +++ b/src/agentex/types/task_message_delta.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Union +from typing_extensions import Annotated, TypeAlias + +from .._utils import PropertyInfo +from .data_delta import DataDelta +from .text_delta import TextDelta +from .tool_request_delta import ToolRequestDelta +from .tool_response_delta import ToolResponseDelta + +__all__ = ["TaskMessageDelta"] + +TaskMessageDelta: TypeAlias = Annotated[ + Union[TextDelta, DataDelta, ToolRequestDelta, ToolResponseDelta], PropertyInfo(discriminator="type") +] diff --git a/src/agentex/types/text_delta.py b/src/agentex/types/text_delta.py new file mode 100644 index 00000000..29a60cfd --- /dev/null +++ b/src/agentex/types/text_delta.py @@ -0,0 +1,14 @@ +# 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__ = ["TextDelta"] + + +class TextDelta(BaseModel): + text_delta: Optional[str] = None + + type: Optional[Literal["text"]] = None diff --git a/src/agentex/types/tool_request_delta.py b/src/agentex/types/tool_request_delta.py new file mode 100644 index 00000000..7877dfdd --- /dev/null +++ b/src/agentex/types/tool_request_delta.py @@ -0,0 +1,18 @@ +# 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__ = ["ToolRequestDelta"] + + +class ToolRequestDelta(BaseModel): + name: str + + tool_call_id: str + + arguments_delta: Optional[str] = None + + type: Optional[Literal["tool_request"]] = None diff --git a/src/agentex/types/tool_response_delta.py b/src/agentex/types/tool_response_delta.py new file mode 100644 index 00000000..383770db --- /dev/null +++ b/src/agentex/types/tool_response_delta.py @@ -0,0 +1,18 @@ +# 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__ = ["ToolResponseDelta"] + + +class ToolResponseDelta(BaseModel): + name: str + + tool_call_id: str + + content_delta: Optional[str] = None + + type: Optional[Literal["tool_response"]] = None diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index b2819f31..7cb79375 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -9,7 +9,11 @@ from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type -from agentex.types import Agent, AgentListResponse +from agentex.types import ( + Agent, + AgentRpcResponse, + AgentListResponse, +) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -229,7 +233,7 @@ def test_method_rpc(self, client: Agentex) -> None: method="event/send", params={}, ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -244,7 +248,7 @@ def test_method_rpc_with_all_params(self, client: Agentex) -> None: id=0, jsonrpc="2.0", ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -258,7 +262,7 @@ def test_raw_response_rpc(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -272,7 +276,7 @@ def test_streaming_response_rpc(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -294,7 +298,7 @@ def test_method_rpc_by_name(self, client: Agentex) -> None: method="event/send", params={}, ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -309,7 +313,7 @@ def test_method_rpc_by_name_with_all_params(self, client: Agentex) -> None: id=0, jsonrpc="2.0", ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -323,7 +327,7 @@ def test_raw_response_rpc_by_name(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -337,7 +341,7 @@ def test_streaming_response_rpc_by_name(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -569,7 +573,7 @@ async def test_method_rpc(self, async_client: AsyncAgentex) -> None: method="event/send", params={}, ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -584,7 +588,7 @@ async def test_method_rpc_with_all_params(self, async_client: AsyncAgentex) -> N id=0, jsonrpc="2.0", ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -598,7 +602,7 @@ async def test_raw_response_rpc(self, async_client: AsyncAgentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -612,7 +616,7 @@ async def test_streaming_response_rpc(self, async_client: AsyncAgentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -634,7 +638,7 @@ async def test_method_rpc_by_name(self, async_client: AsyncAgentex) -> None: method="event/send", params={}, ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -649,7 +653,7 @@ async def test_method_rpc_by_name_with_all_params(self, async_client: AsyncAgent id=0, jsonrpc="2.0", ) - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -663,7 +667,7 @@ async def test_raw_response_rpc_by_name(self, async_client: AsyncAgentex) -> Non assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -677,7 +681,7 @@ async def test_streaming_response_rpc_by_name(self, async_client: AsyncAgentex) assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(object, agent, path=["response"]) + assert_matches_type(AgentRpcResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_tasks.py b/tests/api_resources/test_tasks.py index 0c9af1b4..97f20453 100644 --- a/tests/api_resources/test_tasks.py +++ b/tests/api_resources/test_tasks.py @@ -9,7 +9,7 @@ from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type -from agentex.types import Task, TaskListResponse +from agentex.types import Task, TaskListResponse, TaskDeleteResponse, TaskDeleteByNameResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -93,7 +93,7 @@ def test_method_delete(self, client: Agentex) -> None: task = client.tasks.delete( "task_id", ) - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -105,7 +105,7 @@ def test_raw_response_delete(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -117,7 +117,7 @@ def test_streaming_response_delete(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -135,7 +135,7 @@ def test_method_delete_by_name(self, client: Agentex) -> None: task = client.tasks.delete_by_name( "task_name", ) - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteByNameResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -147,7 +147,7 @@ def test_raw_response_delete_by_name(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteByNameResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -159,7 +159,7 @@ def test_streaming_response_delete_by_name(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteByNameResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -377,7 +377,7 @@ async def test_method_delete(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.delete( "task_id", ) - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -389,7 +389,7 @@ async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -401,7 +401,7 @@ async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -419,7 +419,7 @@ async def test_method_delete_by_name(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.delete_by_name( "task_name", ) - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteByNameResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -431,7 +431,7 @@ async def test_raw_response_delete_by_name(self, async_client: AsyncAgentex) -> assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteByNameResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -443,7 +443,7 @@ async def test_streaming_response_delete_by_name(self, async_client: AsyncAgente assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteByNameResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True From 757d8331c4150463383f5bd97104ff92da6261ca Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 23 Jul 2025 20:02:17 +0000 Subject: [PATCH 0038/1108] feat(api): manual updates --- .stats.yml | 2 +- README.md | 6 +++--- pyproject.toml | 2 +- requirements-dev.lock | 16 ++++++++-------- requirements.lock | 16 ++++++++-------- 5 files changed, 21 insertions(+), 21 deletions(-) diff --git a/.stats.yml b/.stats.yml index a8d58116..26d5f8ee 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-62a09183a027c64707ad1b9d7a5ccc66c8abf3965e6075282cb5ab72f742a2b3.yml openapi_spec_hash: 47f43703822077a82e2edf82d4b7e0e5 -config_hash: 2e4b423af3db79ebd8170c401ea9093a +config_hash: e9fb383df76f572ee9aefe7b876adc2f diff --git a/README.md b/README.md index 588fc8cc..f0cdff86 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ # Agentex Python API library -[![PyPI version](https://img.shields.io/pypi/v/agentex.svg?label=pypi%20(stable))](https://pypi.org/project/agentex/) +[![PyPI version](https://img.shields.io/pypi/v/agentex-sdk.svg?label=pypi%20(stable))](https://pypi.org/project/agentex-sdk/) The Agentex Python library provides convenient access to the Agentex REST API from any Python 3.8+ application. The library includes type definitions for all request params and response fields, @@ -21,7 +21,7 @@ pip install git+ssh://git@github.com/scaleapi/agentex-python.git ``` > [!NOTE] -> Once this package is [published to PyPI](https://www.stainless.com/docs/guides/publish), this will become: `pip install --pre agentex` +> Once this package is [published to PyPI](https://www.stainless.com/docs/guides/publish), this will become: `pip install --pre agentex-sdk` ## Usage @@ -78,7 +78,7 @@ You can enable this by installing `aiohttp`: ```sh # install from the production repo -pip install 'agentex[aiohttp] @ git+ssh://git@github.com/scaleapi/agentex-python.git' +pip install 'agentex-sdk[aiohttp] @ git+ssh://git@github.com/scaleapi/agentex-python.git' ``` Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`: diff --git a/pyproject.toml b/pyproject.toml index 29885d1d..248fbbb8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,5 +1,5 @@ [project] -name = "agentex" +name = "agentex-sdk" version = "0.1.0-alpha.5" description = "The official Python library for the agentex API" dynamic = ["readme"] diff --git a/requirements-dev.lock b/requirements-dev.lock index f82de72c..56a38441 100644 --- a/requirements-dev.lock +++ b/requirements-dev.lock @@ -13,14 +13,14 @@ aiohappyeyeballs==2.6.1 # via aiohttp aiohttp==3.12.8 - # via agentex + # via agentex-sdk # via httpx-aiohttp aiosignal==1.3.2 # via aiohttp annotated-types==0.6.0 # via pydantic anyio==4.4.0 - # via agentex + # via agentex-sdk # via httpx argcomplete==3.1.2 # via nox @@ -37,7 +37,7 @@ dirty-equals==0.6.0 distlib==0.3.7 # via virtualenv distro==1.8.0 - # via agentex + # via agentex-sdk exceptiongroup==1.2.2 # via anyio # via pytest @@ -53,11 +53,11 @@ h11==0.16.0 httpcore==1.0.9 # via httpx httpx==0.28.1 - # via agentex + # via agentex-sdk # via httpx-aiohttp # via respx httpx-aiohttp==0.1.8 - # via agentex + # via agentex-sdk idna==3.4 # via anyio # via httpx @@ -90,7 +90,7 @@ propcache==0.3.1 # via aiohttp # via yarl pydantic==2.10.3 - # via agentex + # via agentex-sdk pydantic-core==2.27.1 # via pydantic pygments==2.18.0 @@ -113,14 +113,14 @@ setuptools==68.2.2 six==1.16.0 # via python-dateutil sniffio==1.3.0 - # via agentex + # via agentex-sdk # via anyio time-machine==2.9.0 tomli==2.0.2 # via mypy # via pytest typing-extensions==4.12.2 - # via agentex + # via agentex-sdk # via anyio # via multidict # via mypy diff --git a/requirements.lock b/requirements.lock index a6d3556d..a4e7e943 100644 --- a/requirements.lock +++ b/requirements.lock @@ -13,14 +13,14 @@ aiohappyeyeballs==2.6.1 # via aiohttp aiohttp==3.12.8 - # via agentex + # via agentex-sdk # via httpx-aiohttp aiosignal==1.3.2 # via aiohttp annotated-types==0.6.0 # via pydantic anyio==4.4.0 - # via agentex + # via agentex-sdk # via httpx async-timeout==5.0.1 # via aiohttp @@ -30,7 +30,7 @@ certifi==2023.7.22 # via httpcore # via httpx distro==1.8.0 - # via agentex + # via agentex-sdk exceptiongroup==1.2.2 # via anyio frozenlist==1.6.2 @@ -41,10 +41,10 @@ h11==0.16.0 httpcore==1.0.9 # via httpx httpx==0.28.1 - # via agentex + # via agentex-sdk # via httpx-aiohttp httpx-aiohttp==0.1.8 - # via agentex + # via agentex-sdk idna==3.4 # via anyio # via httpx @@ -56,14 +56,14 @@ propcache==0.3.1 # via aiohttp # via yarl pydantic==2.10.3 - # via agentex + # via agentex-sdk pydantic-core==2.27.1 # via pydantic sniffio==1.3.0 - # via agentex + # via agentex-sdk # via anyio typing-extensions==4.12.2 - # via agentex + # via agentex-sdk # via anyio # via multidict # via pydantic From 114e41386c65b7cff789d26b1b0b253243c0501a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 23 Jul 2025 20:04:58 +0000 Subject: [PATCH 0039/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index e8285b71..4f9005ea 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.1.0-alpha.5" + ".": "0.1.0-alpha.6" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 248fbbb8..c376cee2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.1.0-alpha.5" +version = "0.1.0-alpha.6" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 6c4f3e31..a4a7b2ff 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.1.0-alpha.5" # x-release-please-version +__version__ = "0.1.0-alpha.6" # x-release-please-version From 98a7f9bcdf540403cf43cd9e97aebd2fa5d588df Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 23 Jul 2025 22:59:53 +0000 Subject: [PATCH 0040/1108] feat(api): manual updates --- .stats.yml | 2 +- README.md | 11 ++++------- 2 files changed, 5 insertions(+), 8 deletions(-) diff --git a/.stats.yml b/.stats.yml index 26d5f8ee..d5f8c8ab 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-62a09183a027c64707ad1b9d7a5ccc66c8abf3965e6075282cb5ab72f742a2b3.yml openapi_spec_hash: 47f43703822077a82e2edf82d4b7e0e5 -config_hash: e9fb383df76f572ee9aefe7b876adc2f +config_hash: 8691ea87e9147c7f77e63100041c1a3c diff --git a/README.md b/README.md index f0cdff86..d824e440 100644 --- a/README.md +++ b/README.md @@ -16,13 +16,10 @@ The full API of this library can be found in [api.md](api.md). ## Installation ```sh -# install from the production repo -pip install git+ssh://git@github.com/scaleapi/agentex-python.git +# install from PyPI +pip install --pre agentex-sdk ``` -> [!NOTE] -> Once this package is [published to PyPI](https://www.stainless.com/docs/guides/publish), this will become: `pip install --pre agentex-sdk` - ## Usage The full API of this library can be found in [api.md](api.md). @@ -77,8 +74,8 @@ By default, the async client uses `httpx` for HTTP requests. However, for improv You can enable this by installing `aiohttp`: ```sh -# install from the production repo -pip install 'agentex-sdk[aiohttp] @ git+ssh://git@github.com/scaleapi/agentex-python.git' +# install from PyPI +pip install --pre agentex-sdk[aiohttp] ``` Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`: From edd497fbfdbf934cc82be49f7e650994e37e88e2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 23 Jul 2025 23:03:33 +0000 Subject: [PATCH 0041/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- README.md | 4 ++-- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 4f9005ea..3d2ac0bd 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.1.0-alpha.6" + ".": "0.1.0" } \ No newline at end of file diff --git a/README.md b/README.md index d824e440..45a6c419 100644 --- a/README.md +++ b/README.md @@ -17,7 +17,7 @@ The full API of this library can be found in [api.md](api.md). ```sh # install from PyPI -pip install --pre agentex-sdk +pip install agentex-sdk ``` ## Usage @@ -75,7 +75,7 @@ You can enable this by installing `aiohttp`: ```sh # install from PyPI -pip install --pre agentex-sdk[aiohttp] +pip install agentex-sdk[aiohttp] ``` Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`: diff --git a/pyproject.toml b/pyproject.toml index c376cee2..b512a19f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.1.0-alpha.6" +version = "0.1.0" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index a4a7b2ff..b89c1711 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.1.0-alpha.6" # x-release-please-version +__version__ = "0.1.0" # x-release-please-version From 2890a277398191a6e8670f0c921fac3c202408f6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 23 Jul 2025 23:54:44 +0000 Subject: [PATCH 0042/1108] feat(api): manual updates --- .stats.yml | 2 +- api.md | 6 -- src/agentex/types/__init__.py | 1 - src/agentex/types/shared/__init__.py | 3 - .../types/shared/task_message_update.py | 83 ------------------- 5 files changed, 1 insertion(+), 94 deletions(-) delete mode 100644 src/agentex/types/shared/__init__.py delete mode 100644 src/agentex/types/shared/task_message_update.py diff --git a/.stats.yml b/.stats.yml index d5f8c8ab..bad9b200 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-62a09183a027c64707ad1b9d7a5ccc66c8abf3965e6075282cb5ab72f742a2b3.yml openapi_spec_hash: 47f43703822077a82e2edf82d4b7e0e5 -config_hash: 8691ea87e9147c7f77e63100041c1a3c +config_hash: dc388766b3eba23cc8e18aa81563182d diff --git a/api.md b/api.md index 223b095e..0167ad25 100644 --- a/api.md +++ b/api.md @@ -1,9 +1,3 @@ -# Shared Types - -```python -from agentex.types import TaskMessageUpdate -``` - # Agents Types: diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 5623fb8a..7092f51a 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -7,7 +7,6 @@ from .agent import Agent as Agent from .event import Event as Event from .state import State as State -from .shared import TaskMessageUpdate as TaskMessageUpdate from .acp_type import AcpType as AcpType from .data_delta import DataDelta as DataDelta from .text_delta import TextDelta as TextDelta diff --git a/src/agentex/types/shared/__init__.py b/src/agentex/types/shared/__init__.py deleted file mode 100644 index 7b5a4954..00000000 --- a/src/agentex/types/shared/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .task_message_update import TaskMessageUpdate as TaskMessageUpdate diff --git a/src/agentex/types/shared/task_message_update.py b/src/agentex/types/shared/task_message_update.py deleted file mode 100644 index cc01b598..00000000 --- a/src/agentex/types/shared/task_message_update.py +++ /dev/null @@ -1,83 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import Union, Optional -from typing_extensions import Literal, Annotated, TypeAlias - -from ..._utils import PropertyInfo -from ..._models import BaseModel -from ..task_message import TaskMessage -from ..task_message_delta import TaskMessageDelta -from ..task_message_content import TaskMessageContent - -__all__ = [ - "TaskMessageUpdate", - "StreamTaskMessageStart", - "StreamTaskMessageDelta", - "StreamTaskMessageFull", - "StreamTaskMessageDone", -] - - -class StreamTaskMessageStart(BaseModel): - content: TaskMessageContent - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["start"]] = None - - -class StreamTaskMessageDelta(BaseModel): - delta: Optional[TaskMessageDelta] = None - """Delta for text updates""" - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["delta"]] = None - - -class StreamTaskMessageFull(BaseModel): - content: TaskMessageContent - - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["full"]] = None - - -class StreamTaskMessageDone(BaseModel): - index: Optional[int] = None - - parent_task_message: Optional[TaskMessage] = None - """Represents a message in the agent system. - - This entity is used to store messages in MongoDB, with each message associated - with a specific task. - """ - - type: Optional[Literal["done"]] = None - - -TaskMessageUpdate: TypeAlias = Annotated[ - Union[StreamTaskMessageStart, StreamTaskMessageDelta, StreamTaskMessageFull, StreamTaskMessageDone], - PropertyInfo(discriminator="type"), -] From ddc7e3b8ebbba91fa7acbdc89cc929488a53b8fa Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 23 Jul 2025 23:58:38 +0000 Subject: [PATCH 0043/1108] feat(api): manual updates --- .stats.yml | 2 +- api.md | 7 +- src/agentex/types/__init__.py | 1 + src/agentex/types/shared/__init__.py | 3 + .../types/shared/task_message_update.py | 83 +++++++++++++++++++ 5 files changed, 94 insertions(+), 2 deletions(-) create mode 100644 src/agentex/types/shared/__init__.py create mode 100644 src/agentex/types/shared/task_message_update.py diff --git a/.stats.yml b/.stats.yml index bad9b200..caa26cd6 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-62a09183a027c64707ad1b9d7a5ccc66c8abf3965e6075282cb5ab72f742a2b3.yml openapi_spec_hash: 47f43703822077a82e2edf82d4b7e0e5 -config_hash: dc388766b3eba23cc8e18aa81563182d +config_hash: 5eaa2103a510f706c6dafdf62f809428 diff --git a/api.md b/api.md index 0167ad25..3d2b9ae7 100644 --- a/api.md +++ b/api.md @@ -1,3 +1,9 @@ +# Shared Types + +```python +from agentex.types import TaskMessageUpdate +``` + # Agents Types: @@ -13,7 +19,6 @@ from agentex.types import ( DataDelta, TaskMessageContent, TaskMessageDelta, - TaskMessageUpdate, TextDelta, ToolRequestDelta, ToolResponseDelta, diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 7092f51a..5623fb8a 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -7,6 +7,7 @@ from .agent import Agent as Agent from .event import Event as Event from .state import State as State +from .shared import TaskMessageUpdate as TaskMessageUpdate from .acp_type import AcpType as AcpType from .data_delta import DataDelta as DataDelta from .text_delta import TextDelta as TextDelta diff --git a/src/agentex/types/shared/__init__.py b/src/agentex/types/shared/__init__.py new file mode 100644 index 00000000..7b5a4954 --- /dev/null +++ b/src/agentex/types/shared/__init__.py @@ -0,0 +1,3 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .task_message_update import TaskMessageUpdate as TaskMessageUpdate diff --git a/src/agentex/types/shared/task_message_update.py b/src/agentex/types/shared/task_message_update.py new file mode 100644 index 00000000..cc01b598 --- /dev/null +++ b/src/agentex/types/shared/task_message_update.py @@ -0,0 +1,83 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Union, Optional +from typing_extensions import Literal, Annotated, TypeAlias + +from ..._utils import PropertyInfo +from ..._models import BaseModel +from ..task_message import TaskMessage +from ..task_message_delta import TaskMessageDelta +from ..task_message_content import TaskMessageContent + +__all__ = [ + "TaskMessageUpdate", + "StreamTaskMessageStart", + "StreamTaskMessageDelta", + "StreamTaskMessageFull", + "StreamTaskMessageDone", +] + + +class StreamTaskMessageStart(BaseModel): + content: TaskMessageContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["start"]] = None + + +class StreamTaskMessageDelta(BaseModel): + delta: Optional[TaskMessageDelta] = None + """Delta for text updates""" + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["delta"]] = None + + +class StreamTaskMessageFull(BaseModel): + content: TaskMessageContent + + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["full"]] = None + + +class StreamTaskMessageDone(BaseModel): + index: Optional[int] = None + + parent_task_message: Optional[TaskMessage] = None + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message associated + with a specific task. + """ + + type: Optional[Literal["done"]] = None + + +TaskMessageUpdate: TypeAlias = Annotated[ + Union[StreamTaskMessageStart, StreamTaskMessageDelta, StreamTaskMessageFull, StreamTaskMessageDone], + PropertyInfo(discriminator="type"), +] From a2f92a3e41430c3e96c80e4b6b57a95608dd0289 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 24 Jul 2025 01:02:48 +0000 Subject: [PATCH 0044/1108] feat(api): manual updates --- .stats.yml | 2 +- api.md | 7 +------ src/agentex/types/__init__.py | 2 +- src/agentex/types/shared/__init__.py | 3 --- src/agentex/types/{shared => }/task_message_update.py | 10 +++++----- 5 files changed, 8 insertions(+), 16 deletions(-) delete mode 100644 src/agentex/types/shared/__init__.py rename src/agentex/types/{shared => }/task_message_update.py (90%) diff --git a/.stats.yml b/.stats.yml index caa26cd6..8701346d 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-62a09183a027c64707ad1b9d7a5ccc66c8abf3965e6075282cb5ab72f742a2b3.yml openapi_spec_hash: 47f43703822077a82e2edf82d4b7e0e5 -config_hash: 5eaa2103a510f706c6dafdf62f809428 +config_hash: 8d5db979856e35045ae2cdc248ddae47 diff --git a/api.md b/api.md index 3d2b9ae7..0167ad25 100644 --- a/api.md +++ b/api.md @@ -1,9 +1,3 @@ -# Shared Types - -```python -from agentex.types import TaskMessageUpdate -``` - # Agents Types: @@ -19,6 +13,7 @@ from agentex.types import ( DataDelta, TaskMessageContent, TaskMessageDelta, + TaskMessageUpdate, TextDelta, ToolRequestDelta, ToolResponseDelta, diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 5623fb8a..94baf2ca 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -7,7 +7,6 @@ from .agent import Agent as Agent from .event import Event as Event from .state import State as State -from .shared import TaskMessageUpdate as TaskMessageUpdate from .acp_type import AcpType as AcpType from .data_delta import DataDelta as DataDelta from .text_delta import TextDelta as TextDelta @@ -38,6 +37,7 @@ from .state_create_params import StateCreateParams as StateCreateParams from .state_list_response import StateListResponse as StateListResponse from .state_update_params import StateUpdateParams as StateUpdateParams +from .task_message_update import TaskMessageUpdate as TaskMessageUpdate from .tool_response_delta import ToolResponseDelta as ToolResponseDelta from .tracker_list_params import TrackerListParams as TrackerListParams from .task_delete_response import TaskDeleteResponse as TaskDeleteResponse diff --git a/src/agentex/types/shared/__init__.py b/src/agentex/types/shared/__init__.py deleted file mode 100644 index 7b5a4954..00000000 --- a/src/agentex/types/shared/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .task_message_update import TaskMessageUpdate as TaskMessageUpdate diff --git a/src/agentex/types/shared/task_message_update.py b/src/agentex/types/task_message_update.py similarity index 90% rename from src/agentex/types/shared/task_message_update.py rename to src/agentex/types/task_message_update.py index cc01b598..13e1e821 100644 --- a/src/agentex/types/shared/task_message_update.py +++ b/src/agentex/types/task_message_update.py @@ -3,11 +3,11 @@ from typing import Union, Optional from typing_extensions import Literal, Annotated, TypeAlias -from ..._utils import PropertyInfo -from ..._models import BaseModel -from ..task_message import TaskMessage -from ..task_message_delta import TaskMessageDelta -from ..task_message_content import TaskMessageContent +from .._utils import PropertyInfo +from .._models import BaseModel +from .task_message import TaskMessage +from .task_message_delta import TaskMessageDelta +from .task_message_content import TaskMessageContent __all__ = [ "TaskMessageUpdate", From 4a32650271354d17b5bf8c7dd1ceba19511da037 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 24 Jul 2025 01:10:17 +0000 Subject: [PATCH 0045/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 3d2ac0bd..5547f83e 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.1.0" + ".": "0.1.1" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index b512a19f..e9d8baf7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.1.0" +version = "0.1.1" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index b89c1711..9842f69a 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.1.0" # x-release-please-version +__version__ = "0.1.1" # x-release-please-version From 5ff5844da0b0d0929288e590704c80c6464723b5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 24 Jul 2025 03:35:47 +0000 Subject: [PATCH 0046/1108] feat(api): update typescript sdk with big changes --- .stats.yml | 2 +- api.md | 1 - src/agentex/resources/agents.py | 11 ++-- src/agentex/types/agent_rpc_by_name_params.py | 60 +++++++++++++++++-- src/agentex/types/agent_rpc_params.py | 34 ++++++++--- src/agentex/types/agent_rpc_params1.py | 21 ------- 6 files changed, 88 insertions(+), 41 deletions(-) delete mode 100644 src/agentex/types/agent_rpc_params1.py diff --git a/.stats.yml b/.stats.yml index 8701346d..8a4f92bd 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-62a09183a027c64707ad1b9d7a5ccc66c8abf3965e6075282cb5ab72f742a2b3.yml openapi_spec_hash: 47f43703822077a82e2edf82d4b7e0e5 -config_hash: 8d5db979856e35045ae2cdc248ddae47 +config_hash: 7c1f6794a184ee175dd94f2f7c2b496b diff --git a/api.md b/api.md index 0167ad25..3c69ec52 100644 --- a/api.md +++ b/api.md @@ -6,7 +6,6 @@ Types: from agentex.types import ( AcpType, Agent, - AgentRpcParams, AgentRpcRequest, AgentRpcResponse, AgentRpcResult, diff --git a/src/agentex/resources/agents.py b/src/agentex/resources/agents.py index 8b329be8..dccba983 100644 --- a/src/agentex/resources/agents.py +++ b/src/agentex/resources/agents.py @@ -7,7 +7,7 @@ import httpx -from ..types import AgentRpcParams, agent_rpc_params, agent_list_params, agent_rpc_by_name_params +from ..types import agent_rpc_params, agent_list_params, agent_rpc_by_name_params from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property @@ -20,7 +20,6 @@ ) from ..types.agent import Agent from .._base_client import make_request_options -from ..types.agent_rpc_params import AgentRpcParams from ..types.agent_rpc_response import AgentRpcResponse from ..types.agent_list_response import AgentListResponse @@ -221,7 +220,7 @@ def rpc( agent_id: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: AgentRpcParams, + params: agent_rpc_params.Params, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -269,7 +268,7 @@ def rpc_by_name( agent_name: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: AgentRpcParams, + params: agent_rpc_by_name_params.Params, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -507,7 +506,7 @@ async def rpc( agent_id: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: AgentRpcParams, + params: agent_rpc_params.Params, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -555,7 +554,7 @@ async def rpc_by_name( agent_name: str, *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], - params: AgentRpcParams, + params: agent_rpc_by_name_params.Params, id: Union[int, str, None] | NotGiven = NOT_GIVEN, jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. diff --git a/src/agentex/types/agent_rpc_by_name_params.py b/src/agentex/types/agent_rpc_by_name_params.py index 5be189d7..b84da84c 100644 --- a/src/agentex/types/agent_rpc_by_name_params.py +++ b/src/agentex/types/agent_rpc_by_name_params.py @@ -2,20 +2,70 @@ from __future__ import annotations -from typing import Union -from typing_extensions import Literal, Required, TypedDict +from typing import Dict, Union, Optional +from typing_extensions import Literal, Required, TypeAlias, TypedDict -from .agent_rpc_params import AgentRpcParams +from .task_message_content_param import TaskMessageContentParam -__all__ = ["AgentRpcByNameParams"] +__all__ = [ + "AgentRpcByNameParams", + "Params", + "ParamsCreateTaskRequest", + "ParamsCancelTaskRequest", + "ParamsSendMessageRequest", + "ParamsSendEventRequest", +] class AgentRpcByNameParams(TypedDict, total=False): method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] - params: Required[AgentRpcParams] + params: Required[Params] """The parameters for the agent RPC request""" id: Union[int, str, None] jsonrpc: Literal["2.0"] + + +class ParamsCreateTaskRequest(TypedDict, total=False): + name: Optional[str] + """The name of the task to create""" + + params: Optional[Dict[str, object]] + """The parameters for the task""" + + +class ParamsCancelTaskRequest(TypedDict, total=False): + task_id: Optional[str] + """The ID of the task to cancel. Either this or task_name must be provided.""" + + task_name: Optional[str] + """The name of the task to cancel. Either this or task_id must be provided.""" + + +class ParamsSendMessageRequest(TypedDict, total=False): + content: Required[TaskMessageContentParam] + """The message that was sent to the agent""" + + stream: bool + """Whether to stream the response message back to the client""" + + task_id: Optional[str] + """The ID of the task that the message was sent to""" + + +class ParamsSendEventRequest(TypedDict, total=False): + content: Optional[TaskMessageContentParam] + """The content to send to the event""" + + task_id: Optional[str] + """The ID of the task that the event was sent to""" + + task_name: Optional[str] + """The name of the task that the event was sent to""" + + +Params: TypeAlias = Union[ + ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest +] diff --git a/src/agentex/types/agent_rpc_params.py b/src/agentex/types/agent_rpc_params.py index 5082b18c..e4ae3ab1 100644 --- a/src/agentex/types/agent_rpc_params.py +++ b/src/agentex/types/agent_rpc_params.py @@ -3,14 +3,32 @@ from __future__ import annotations from typing import Dict, Union, Optional -from typing_extensions import Required, TypeAlias, TypedDict +from typing_extensions import Literal, Required, TypeAlias, TypedDict from .task_message_content_param import TaskMessageContentParam -__all__ = ["AgentRpcParams", "CreateTaskRequest", "CancelTaskRequest", "SendMessageRequest", "SendEventRequest"] +__all__ = [ + "AgentRpcParams", + "Params", + "ParamsCreateTaskRequest", + "ParamsCancelTaskRequest", + "ParamsSendMessageRequest", + "ParamsSendEventRequest", +] -class CreateTaskRequest(TypedDict, total=False): +class AgentRpcParams(TypedDict, total=False): + method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] + + params: Required[Params] + """The parameters for the agent RPC request""" + + id: Union[int, str, None] + + jsonrpc: Literal["2.0"] + + +class ParamsCreateTaskRequest(TypedDict, total=False): name: Optional[str] """The name of the task to create""" @@ -18,7 +36,7 @@ class CreateTaskRequest(TypedDict, total=False): """The parameters for the task""" -class CancelTaskRequest(TypedDict, total=False): +class ParamsCancelTaskRequest(TypedDict, total=False): task_id: Optional[str] """The ID of the task to cancel. Either this or task_name must be provided.""" @@ -26,7 +44,7 @@ class CancelTaskRequest(TypedDict, total=False): """The name of the task to cancel. Either this or task_id must be provided.""" -class SendMessageRequest(TypedDict, total=False): +class ParamsSendMessageRequest(TypedDict, total=False): content: Required[TaskMessageContentParam] """The message that was sent to the agent""" @@ -37,7 +55,7 @@ class SendMessageRequest(TypedDict, total=False): """The ID of the task that the message was sent to""" -class SendEventRequest(TypedDict, total=False): +class ParamsSendEventRequest(TypedDict, total=False): content: Optional[TaskMessageContentParam] """The content to send to the event""" @@ -48,4 +66,6 @@ class SendEventRequest(TypedDict, total=False): """The name of the task that the event was sent to""" -AgentRpcParams: TypeAlias = Union[CreateTaskRequest, CancelTaskRequest, SendMessageRequest, SendEventRequest] +Params: TypeAlias = Union[ + ParamsCreateTaskRequest, ParamsCancelTaskRequest, ParamsSendMessageRequest, ParamsSendEventRequest +] diff --git a/src/agentex/types/agent_rpc_params1.py b/src/agentex/types/agent_rpc_params1.py deleted file mode 100644 index 3eae8b68..00000000 --- a/src/agentex/types/agent_rpc_params1.py +++ /dev/null @@ -1,21 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Union -from typing_extensions import Literal, Required, TypedDict - -from . import agent_rpc_params - -__all__ = ["AgentRpcParams"] - - -class AgentRpcParams(TypedDict, total=False): - method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]] - - params: Required[agent_rpc_params.AgentRpcParams] - """The parameters for the agent RPC request""" - - id: Union[int, str, None] - - jsonrpc: Literal["2.0"] From 3e9134ed502539abaf0fdc118573335b130e2dbb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 24 Jul 2025 14:24:36 +0000 Subject: [PATCH 0047/1108] chore(project): add settings file for vscode --- .gitignore | 1 - .vscode/settings.json | 3 +++ 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 .vscode/settings.json diff --git a/.gitignore b/.gitignore index 87797408..95ceb189 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,4 @@ .prism.log -.vscode _dev __pycache__ diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 00000000..5b010307 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "python.analysis.importFormat": "relative", +} From 13337780ef8af1d509306e7ee61562cf43d8e480 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 24 Jul 2025 17:24:12 +0000 Subject: [PATCH 0048/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 8a4f92bd..fd51d354 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-62a09183a027c64707ad1b9d7a5ccc66c8abf3965e6075282cb5ab72f742a2b3.yml -openapi_spec_hash: 47f43703822077a82e2edf82d4b7e0e5 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-782d59cf134b51ddd5058ae6e1630057093a6034b1d90663ab67836802b67cc6.yml +openapi_spec_hash: 3356926852d5d095d572b4fdce242836 config_hash: 7c1f6794a184ee175dd94f2f7c2b496b From 89f5c5f22c1bd2f7235f9811170375a7fafd27d4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 25 Jul 2025 15:50:49 +0000 Subject: [PATCH 0049/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 5547f83e..10f30916 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.1.1" + ".": "0.2.0" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index e9d8baf7..a014ab89 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.1.1" +version = "0.2.0" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 9842f69a..aba87a2e 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.1.1" # x-release-please-version +__version__ = "0.2.0" # x-release-please-version From 00f9f50d5531e8a3f1c959464bb4ce5c79808d56 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 27 Jul 2025 19:20:37 +0000 Subject: [PATCH 0050/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 10f30916..b06ba919 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.2.0" + ".": "0.2.1" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index a014ab89..b55eb583 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.2.0" +version = "0.2.1" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index aba87a2e..f2c7f480 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.2.0" # x-release-please-version +__version__ = "0.2.1" # x-release-please-version From d779282a473cff812fccf26351b580f1857353a3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 27 Jul 2025 19:24:17 +0000 Subject: [PATCH 0051/1108] feat(api): api update --- .stats.yml | 4 ++-- src/agentex/resources/tasks.py | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/.stats.yml b/.stats.yml index fd51d354..c2c3329d 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-782d59cf134b51ddd5058ae6e1630057093a6034b1d90663ab67836802b67cc6.yml -openapi_spec_hash: 3356926852d5d095d572b4fdce242836 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-a42f3fa6193375625aacb4420b7ea094dfa7b6800d902d600d267bfc4e60830f.yml +openapi_spec_hash: ac8e75aa452349aaaa2ac526032900f8 config_hash: 7c1f6794a184ee175dd94f2f7c2b496b diff --git a/src/agentex/resources/tasks.py b/src/agentex/resources/tasks.py index 6c6ce9d0..8bd17670 100644 --- a/src/agentex/resources/tasks.py +++ b/src/agentex/resources/tasks.py @@ -206,7 +206,7 @@ def stream_events( timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, ) -> Stream[object]: """ - Stream events for a task by its unique ID. + Stream message updates for a task by its unique ID. Args: extra_headers: Send extra headers @@ -241,7 +241,7 @@ def stream_events_by_name( timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, ) -> Stream[object]: """ - Stream events for a task by its unique name. + Stream message updates for a task by its unique name. Args: extra_headers: Send extra headers @@ -448,7 +448,7 @@ async def stream_events( timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, ) -> AsyncStream[object]: """ - Stream events for a task by its unique ID. + Stream message updates for a task by its unique ID. Args: extra_headers: Send extra headers @@ -483,7 +483,7 @@ async def stream_events_by_name( timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, ) -> AsyncStream[object]: """ - Stream events for a task by its unique name. + Stream message updates for a task by its unique name. Args: extra_headers: Send extra headers From dc3a74e9a006b4a68b6b3f9a66e25c7bf5197689 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 28 Jul 2025 17:24:36 +0000 Subject: [PATCH 0052/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index c2c3329d..5f6e82ac 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-a42f3fa6193375625aacb4420b7ea094dfa7b6800d902d600d267bfc4e60830f.yml -openapi_spec_hash: ac8e75aa452349aaaa2ac526032900f8 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-ed22476258be08ff765c68dcb29c08baf3e4783c98edac50d1e8003e9487db37.yml +openapi_spec_hash: d4010bb4bf479073328ca00be01a7b96 config_hash: 7c1f6794a184ee175dd94f2f7c2b496b From 9eea8c4839be01f393494ab3d19c0adf90cf624f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 28 Jul 2025 21:50:17 +0000 Subject: [PATCH 0053/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index b06ba919..d66ca57c 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.2.1" + ".": "0.2.2" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index b55eb583..3a304349 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.2.1" +version = "0.2.2" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index f2c7f480..05f65d5f 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.2.1" # x-release-please-version +__version__ = "0.2.2" # x-release-please-version From 67729173faf9afdd56ac8cd7c0edb0efdcb78dc2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 29 Jul 2025 00:18:11 +0000 Subject: [PATCH 0054/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index d66ca57c..ccdf8aa7 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.2.2" + ".": "0.2.3" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 3a304349..af0776aa 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.2.2" +version = "0.2.3" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 05f65d5f..5363be43 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.2.2" # x-release-please-version +__version__ = "0.2.3" # x-release-please-version From 8884866b930046a3544264053f9cc043a8fb2414 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 29 Jul 2025 01:59:45 +0000 Subject: [PATCH 0055/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index ccdf8aa7..9aa540f7 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.2.3" + ".": "0.2.4" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index af0776aa..3e66c529 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.2.3" +version = "0.2.4" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 5363be43..c0d16f84 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.2.3" # x-release-please-version +__version__ = "0.2.4" # x-release-please-version From 0feddbcdbba469326c899185f083293cca4c91b8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 29 Jul 2025 02:24:34 +0000 Subject: [PATCH 0056/1108] feat(api): api update --- .stats.yml | 4 ++-- api.md | 4 ++-- src/agentex/resources/messages/messages.py | 18 ++------------- src/agentex/resources/tasks.py | 9 ++++---- src/agentex/types/__init__.py | 1 - src/agentex/types/message_list_params.py | 4 +--- src/agentex/types/task_delete_response.py | 8 ------- tests/api_resources/test_messages.py | 26 +++++----------------- tests/api_resources/test_tasks.py | 14 ++++++------ 9 files changed, 24 insertions(+), 64 deletions(-) delete mode 100644 src/agentex/types/task_delete_response.py diff --git a/.stats.yml b/.stats.yml index 5f6e82ac..4823b6de 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-ed22476258be08ff765c68dcb29c08baf3e4783c98edac50d1e8003e9487db37.yml -openapi_spec_hash: d4010bb4bf479073328ca00be01a7b96 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-315b05c82c3c0fdc9f058422debc4edc09c04cef2f7ff8605953de11d16c489f.yml +openapi_spec_hash: 1bc36f6ebe0d9d926c4312de7ec9222e config_hash: 7c1f6794a184ee175dd94f2f7c2b496b diff --git a/api.md b/api.md index 3c69ec52..baeabb67 100644 --- a/api.md +++ b/api.md @@ -35,14 +35,14 @@ Methods: Types: ```python -from agentex.types import Task, TaskListResponse, TaskDeleteResponse, TaskDeleteByNameResponse +from agentex.types import Task, TaskListResponse, TaskDeleteByNameResponse ``` Methods: - client.tasks.retrieve(task_id) -> Task - client.tasks.list() -> TaskListResponse -- client.tasks.delete(task_id) -> TaskDeleteResponse +- client.tasks.delete(task_id) -> Task - client.tasks.delete_by_name(task_name) -> TaskDeleteByNameResponse - client.tasks.retrieve_by_name(task_name) -> Task - client.tasks.stream_events(task_id) -> object diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index b7f78c94..794952bd 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -179,7 +179,6 @@ def update( def list( self, *, - task_id: str, limit: Optional[int] | NotGiven = NOT_GIVEN, # 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. @@ -207,13 +206,7 @@ def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=maybe_transform( - { - "task_id": task_id, - "limit": limit, - }, - message_list_params.MessageListParams, - ), + query=maybe_transform({"limit": limit}, message_list_params.MessageListParams), ), cast_to=MessageListResponse, ) @@ -364,7 +357,6 @@ async def update( async def list( self, *, - task_id: str, limit: Optional[int] | NotGiven = NOT_GIVEN, # 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. @@ -392,13 +384,7 @@ async def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=await async_maybe_transform( - { - "task_id": task_id, - "limit": limit, - }, - message_list_params.MessageListParams, - ), + query=await async_maybe_transform({"limit": limit}, message_list_params.MessageListParams), ), cast_to=MessageListResponse, ) diff --git a/src/agentex/resources/tasks.py b/src/agentex/resources/tasks.py index 8bd17670..c095d420 100644 --- a/src/agentex/resources/tasks.py +++ b/src/agentex/resources/tasks.py @@ -17,7 +17,6 @@ from ..types.task import Task from .._base_client import make_request_options from ..types.task_list_response import TaskListResponse -from ..types.task_delete_response import TaskDeleteResponse from ..types.task_delete_by_name_response import TaskDeleteByNameResponse __all__ = ["TasksResource", "AsyncTasksResource"] @@ -105,7 +104,7 @@ def delete( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> TaskDeleteResponse: + ) -> Task: """ Delete a task by its unique ID. @@ -125,7 +124,7 @@ def delete( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=TaskDeleteResponse, + cast_to=Task, ) def delete_by_name( @@ -347,7 +346,7 @@ async def delete( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> TaskDeleteResponse: + ) -> Task: """ Delete a task by its unique ID. @@ -367,7 +366,7 @@ async def delete( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=TaskDeleteResponse, + cast_to=Task, ) async def delete_by_name( diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 94baf2ca..f5794711 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -40,7 +40,6 @@ from .task_message_update import TaskMessageUpdate as TaskMessageUpdate from .tool_response_delta import ToolResponseDelta as ToolResponseDelta from .tracker_list_params import TrackerListParams as TrackerListParams -from .task_delete_response import TaskDeleteResponse as TaskDeleteResponse from .task_message_content import TaskMessageContent as TaskMessageContent from .tool_request_content import ToolRequestContent as ToolRequestContent from .message_create_params import MessageCreateParams as MessageCreateParams diff --git a/src/agentex/types/message_list_params.py b/src/agentex/types/message_list_params.py index 1bdcedb5..8747321e 100644 --- a/src/agentex/types/message_list_params.py +++ b/src/agentex/types/message_list_params.py @@ -3,12 +3,10 @@ from __future__ import annotations from typing import Optional -from typing_extensions import Required, TypedDict +from typing_extensions import TypedDict __all__ = ["MessageListParams"] class MessageListParams(TypedDict, total=False): - task_id: Required[str] - limit: Optional[int] diff --git a/src/agentex/types/task_delete_response.py b/src/agentex/types/task_delete_response.py deleted file mode 100644 index 62104057..00000000 --- a/src/agentex/types/task_delete_response.py +++ /dev/null @@ -1,8 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import Dict -from typing_extensions import TypeAlias - -__all__ = ["TaskDeleteResponse"] - -TaskDeleteResponse: TypeAlias = Dict[str, str] diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py index eb0af8cd..93bd690c 100644 --- a/tests/api_resources/test_messages.py +++ b/tests/api_resources/test_messages.py @@ -229,16 +229,13 @@ def test_path_params_update(self, client: Agentex) -> None: @pytest.mark.skip() @parametrize def test_method_list(self, client: Agentex) -> None: - message = client.messages.list( - task_id="task_id", - ) + message = client.messages.list() assert_matches_type(MessageListResponse, message, path=["response"]) @pytest.mark.skip() @parametrize def test_method_list_with_all_params(self, client: Agentex) -> None: message = client.messages.list( - task_id="task_id", limit=0, ) assert_matches_type(MessageListResponse, message, path=["response"]) @@ -246,9 +243,7 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: @pytest.mark.skip() @parametrize def test_raw_response_list(self, client: Agentex) -> None: - response = client.messages.with_raw_response.list( - task_id="task_id", - ) + response = client.messages.with_raw_response.list() assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -258,9 +253,7 @@ def test_raw_response_list(self, client: Agentex) -> None: @pytest.mark.skip() @parametrize def test_streaming_response_list(self, client: Agentex) -> None: - with client.messages.with_streaming_response.list( - task_id="task_id", - ) as response: + with client.messages.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -484,16 +477,13 @@ async def test_path_params_update(self, async_client: AsyncAgentex) -> None: @pytest.mark.skip() @parametrize async def test_method_list(self, async_client: AsyncAgentex) -> None: - message = await async_client.messages.list( - task_id="task_id", - ) + message = await async_client.messages.list() assert_matches_type(MessageListResponse, message, path=["response"]) @pytest.mark.skip() @parametrize async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.list( - task_id="task_id", limit=0, ) assert_matches_type(MessageListResponse, message, path=["response"]) @@ -501,9 +491,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> @pytest.mark.skip() @parametrize async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: - response = await async_client.messages.with_raw_response.list( - task_id="task_id", - ) + response = await async_client.messages.with_raw_response.list() assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -513,9 +501,7 @@ async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: @pytest.mark.skip() @parametrize async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: - async with async_client.messages.with_streaming_response.list( - task_id="task_id", - ) as response: + async with async_client.messages.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" diff --git a/tests/api_resources/test_tasks.py b/tests/api_resources/test_tasks.py index 97f20453..bf10c953 100644 --- a/tests/api_resources/test_tasks.py +++ b/tests/api_resources/test_tasks.py @@ -9,7 +9,7 @@ from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type -from agentex.types import Task, TaskListResponse, TaskDeleteResponse, TaskDeleteByNameResponse +from agentex.types import Task, TaskListResponse, TaskDeleteByNameResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -93,7 +93,7 @@ def test_method_delete(self, client: Agentex) -> None: task = client.tasks.delete( "task_id", ) - assert_matches_type(TaskDeleteResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -105,7 +105,7 @@ def test_raw_response_delete(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(TaskDeleteResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -117,7 +117,7 @@ def test_streaming_response_delete(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(TaskDeleteResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -377,7 +377,7 @@ async def test_method_delete(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.delete( "task_id", ) - assert_matches_type(TaskDeleteResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -389,7 +389,7 @@ async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(TaskDeleteResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -401,7 +401,7 @@ async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(TaskDeleteResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) assert cast(Any, response.is_closed) is True From f9f433ada731575422e65815096c9e6e94af6266 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 29 Jul 2025 05:59:53 +0000 Subject: [PATCH 0057/1108] feat(api): api update --- .stats.yml | 4 +-- api.md | 10 ++++--- src/agentex/resources/agents.py | 18 +++++++------ src/agentex/resources/messages/messages.py | 22 ++++++++++++++-- src/agentex/resources/tasks.py | 9 ++++--- src/agentex/types/__init__.py | 3 +++ .../types/agent_delete_by_name_response.py | 11 ++++++++ src/agentex/types/agent_delete_response.py | 11 ++++++++ src/agentex/types/message_list_params.py | 5 +++- .../types/task_delete_by_name_response.py | 9 ++++--- src/agentex/types/task_delete_response.py | 11 ++++++++ tests/api_resources/test_agents.py | 26 ++++++++++--------- tests/api_resources/test_messages.py | 26 ++++++++++++++----- tests/api_resources/test_tasks.py | 14 +++++----- 14 files changed, 130 insertions(+), 49 deletions(-) create mode 100644 src/agentex/types/agent_delete_by_name_response.py create mode 100644 src/agentex/types/agent_delete_response.py create mode 100644 src/agentex/types/task_delete_response.py diff --git a/.stats.yml b/.stats.yml index 4823b6de..ab941275 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-315b05c82c3c0fdc9f058422debc4edc09c04cef2f7ff8605953de11d16c489f.yml -openapi_spec_hash: 1bc36f6ebe0d9d926c4312de7ec9222e +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-733bcb26b2f53abaac835267d630274ca18eba7726350b65fa2a74cc490908c1.yml +openapi_spec_hash: f9a141a82a0b19bde31d6ea48ae4d6d6 config_hash: 7c1f6794a184ee175dd94f2f7c2b496b diff --git a/api.md b/api.md index baeabb67..29e04573 100644 --- a/api.md +++ b/api.md @@ -17,6 +17,8 @@ from agentex.types import ( ToolRequestDelta, ToolResponseDelta, AgentListResponse, + AgentDeleteResponse, + AgentDeleteByNameResponse, ) ``` @@ -24,8 +26,8 @@ Methods: - client.agents.retrieve(agent_id) -> Agent - client.agents.list(\*\*params) -> AgentListResponse -- client.agents.delete(agent_id) -> Agent -- client.agents.delete_by_name(agent_name) -> Agent +- client.agents.delete(agent_id) -> AgentDeleteResponse +- client.agents.delete_by_name(agent_name) -> AgentDeleteByNameResponse - client.agents.retrieve_by_name(agent_name) -> Agent - client.agents.rpc(agent_id, \*\*params) -> AgentRpcResponse - client.agents.rpc_by_name(agent_name, \*\*params) -> AgentRpcResponse @@ -35,14 +37,14 @@ Methods: Types: ```python -from agentex.types import Task, TaskListResponse, TaskDeleteByNameResponse +from agentex.types import Task, TaskListResponse, TaskDeleteResponse, TaskDeleteByNameResponse ``` Methods: - client.tasks.retrieve(task_id) -> Task - client.tasks.list() -> TaskListResponse -- client.tasks.delete(task_id) -> Task +- client.tasks.delete(task_id) -> TaskDeleteResponse - client.tasks.delete_by_name(task_name) -> TaskDeleteByNameResponse - client.tasks.retrieve_by_name(task_name) -> Task - client.tasks.stream_events(task_id) -> object diff --git a/src/agentex/resources/agents.py b/src/agentex/resources/agents.py index dccba983..31e332df 100644 --- a/src/agentex/resources/agents.py +++ b/src/agentex/resources/agents.py @@ -22,6 +22,8 @@ from .._base_client import make_request_options from ..types.agent_rpc_response import AgentRpcResponse from ..types.agent_list_response import AgentListResponse +from ..types.agent_delete_response import AgentDeleteResponse +from ..types.agent_delete_by_name_response import AgentDeleteByNameResponse __all__ = ["AgentsResource", "AsyncAgentsResource"] @@ -126,7 +128,7 @@ def delete( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Agent: + ) -> AgentDeleteResponse: """ Delete an agent by its unique ID. @@ -146,7 +148,7 @@ def delete( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Agent, + cast_to=AgentDeleteResponse, ) def delete_by_name( @@ -159,7 +161,7 @@ def delete_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Agent: + ) -> AgentDeleteByNameResponse: """ Delete an agent by its unique name. @@ -179,7 +181,7 @@ def delete_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Agent, + cast_to=AgentDeleteByNameResponse, ) def retrieve_by_name( @@ -412,7 +414,7 @@ async def delete( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Agent: + ) -> AgentDeleteResponse: """ Delete an agent by its unique ID. @@ -432,7 +434,7 @@ async def delete( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Agent, + cast_to=AgentDeleteResponse, ) async def delete_by_name( @@ -445,7 +447,7 @@ async def delete_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Agent: + ) -> AgentDeleteByNameResponse: """ Delete an agent by its unique name. @@ -465,7 +467,7 @@ async def delete_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Agent, + cast_to=AgentDeleteByNameResponse, ) async def retrieve_by_name( diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index 794952bd..d85f63e1 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -179,6 +179,7 @@ def update( def list( self, *, + task_id: str, limit: Optional[int] | NotGiven = NOT_GIVEN, # 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. @@ -191,6 +192,8 @@ def list( List Messages Args: + task_id: The task ID + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -206,7 +209,13 @@ def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=maybe_transform({"limit": limit}, message_list_params.MessageListParams), + query=maybe_transform( + { + "task_id": task_id, + "limit": limit, + }, + message_list_params.MessageListParams, + ), ), cast_to=MessageListResponse, ) @@ -357,6 +366,7 @@ async def update( async def list( self, *, + task_id: str, limit: Optional[int] | NotGiven = NOT_GIVEN, # 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. @@ -369,6 +379,8 @@ async def list( List Messages Args: + task_id: The task ID + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -384,7 +396,13 @@ async def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=await async_maybe_transform({"limit": limit}, message_list_params.MessageListParams), + query=await async_maybe_transform( + { + "task_id": task_id, + "limit": limit, + }, + message_list_params.MessageListParams, + ), ), cast_to=MessageListResponse, ) diff --git a/src/agentex/resources/tasks.py b/src/agentex/resources/tasks.py index c095d420..8bd17670 100644 --- a/src/agentex/resources/tasks.py +++ b/src/agentex/resources/tasks.py @@ -17,6 +17,7 @@ from ..types.task import Task from .._base_client import make_request_options from ..types.task_list_response import TaskListResponse +from ..types.task_delete_response import TaskDeleteResponse from ..types.task_delete_by_name_response import TaskDeleteByNameResponse __all__ = ["TasksResource", "AsyncTasksResource"] @@ -104,7 +105,7 @@ def delete( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Task: + ) -> TaskDeleteResponse: """ Delete a task by its unique ID. @@ -124,7 +125,7 @@ def delete( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Task, + cast_to=TaskDeleteResponse, ) def delete_by_name( @@ -346,7 +347,7 @@ async def delete( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Task: + ) -> TaskDeleteResponse: """ Delete a task by its unique ID. @@ -366,7 +367,7 @@ async def delete( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Task, + cast_to=TaskDeleteResponse, ) async def delete_by_name( diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index f5794711..2a42dd8f 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -40,8 +40,10 @@ from .task_message_update import TaskMessageUpdate as TaskMessageUpdate from .tool_response_delta import ToolResponseDelta as ToolResponseDelta from .tracker_list_params import TrackerListParams as TrackerListParams +from .task_delete_response import TaskDeleteResponse as TaskDeleteResponse from .task_message_content import TaskMessageContent as TaskMessageContent from .tool_request_content import ToolRequestContent as ToolRequestContent +from .agent_delete_response import AgentDeleteResponse as AgentDeleteResponse from .message_create_params import MessageCreateParams as MessageCreateParams from .message_list_response import MessageListResponse as MessageListResponse from .message_update_params import MessageUpdateParams as MessageUpdateParams @@ -53,3 +55,4 @@ from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam from .task_delete_by_name_response import TaskDeleteByNameResponse as TaskDeleteByNameResponse +from .agent_delete_by_name_response import AgentDeleteByNameResponse as AgentDeleteByNameResponse diff --git a/src/agentex/types/agent_delete_by_name_response.py b/src/agentex/types/agent_delete_by_name_response.py new file mode 100644 index 00000000..66e67abc --- /dev/null +++ b/src/agentex/types/agent_delete_by_name_response.py @@ -0,0 +1,11 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .._models import BaseModel + +__all__ = ["AgentDeleteByNameResponse"] + + +class AgentDeleteByNameResponse(BaseModel): + id: str + + message: str diff --git a/src/agentex/types/agent_delete_response.py b/src/agentex/types/agent_delete_response.py new file mode 100644 index 00000000..fbf4ab7f --- /dev/null +++ b/src/agentex/types/agent_delete_response.py @@ -0,0 +1,11 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .._models import BaseModel + +__all__ = ["AgentDeleteResponse"] + + +class AgentDeleteResponse(BaseModel): + id: str + + message: str diff --git a/src/agentex/types/message_list_params.py b/src/agentex/types/message_list_params.py index 8747321e..4911bfa9 100644 --- a/src/agentex/types/message_list_params.py +++ b/src/agentex/types/message_list_params.py @@ -3,10 +3,13 @@ from __future__ import annotations from typing import Optional -from typing_extensions import TypedDict +from typing_extensions import Required, TypedDict __all__ = ["MessageListParams"] class MessageListParams(TypedDict, total=False): + task_id: Required[str] + """The task ID""" + limit: Optional[int] diff --git a/src/agentex/types/task_delete_by_name_response.py b/src/agentex/types/task_delete_by_name_response.py index bea61633..297cff96 100644 --- a/src/agentex/types/task_delete_by_name_response.py +++ b/src/agentex/types/task_delete_by_name_response.py @@ -1,8 +1,11 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Dict -from typing_extensions import TypeAlias +from .._models import BaseModel __all__ = ["TaskDeleteByNameResponse"] -TaskDeleteByNameResponse: TypeAlias = Dict[str, str] + +class TaskDeleteByNameResponse(BaseModel): + id: str + + message: str diff --git a/src/agentex/types/task_delete_response.py b/src/agentex/types/task_delete_response.py new file mode 100644 index 00000000..eb68aadb --- /dev/null +++ b/src/agentex/types/task_delete_response.py @@ -0,0 +1,11 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .._models import BaseModel + +__all__ = ["TaskDeleteResponse"] + + +class TaskDeleteResponse(BaseModel): + id: str + + message: str diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index 7cb79375..0293268f 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -13,6 +13,8 @@ Agent, AgentRpcResponse, AgentListResponse, + AgentDeleteResponse, + AgentDeleteByNameResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -105,7 +107,7 @@ def test_method_delete(self, client: Agentex) -> None: agent = client.agents.delete( "agent_id", ) - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AgentDeleteResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -117,7 +119,7 @@ def test_raw_response_delete(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AgentDeleteResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +131,7 @@ def test_streaming_response_delete(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AgentDeleteResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -147,7 +149,7 @@ def test_method_delete_by_name(self, client: Agentex) -> None: agent = client.agents.delete_by_name( "agent_name", ) - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AgentDeleteByNameResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -159,7 +161,7 @@ def test_raw_response_delete_by_name(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AgentDeleteByNameResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -171,7 +173,7 @@ def test_streaming_response_delete_by_name(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AgentDeleteByNameResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -445,7 +447,7 @@ async def test_method_delete(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.delete( "agent_id", ) - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AgentDeleteResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -457,7 +459,7 @@ async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AgentDeleteResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -469,7 +471,7 @@ async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AgentDeleteResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -487,7 +489,7 @@ async def test_method_delete_by_name(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.delete_by_name( "agent_name", ) - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AgentDeleteByNameResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -499,7 +501,7 @@ async def test_raw_response_delete_by_name(self, async_client: AsyncAgentex) -> assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AgentDeleteByNameResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -511,7 +513,7 @@ async def test_streaming_response_delete_by_name(self, async_client: AsyncAgente assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(Agent, agent, path=["response"]) + assert_matches_type(AgentDeleteByNameResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py index 93bd690c..eb0af8cd 100644 --- a/tests/api_resources/test_messages.py +++ b/tests/api_resources/test_messages.py @@ -229,13 +229,16 @@ def test_path_params_update(self, client: Agentex) -> None: @pytest.mark.skip() @parametrize def test_method_list(self, client: Agentex) -> None: - message = client.messages.list() + message = client.messages.list( + task_id="task_id", + ) assert_matches_type(MessageListResponse, message, path=["response"]) @pytest.mark.skip() @parametrize def test_method_list_with_all_params(self, client: Agentex) -> None: message = client.messages.list( + task_id="task_id", limit=0, ) assert_matches_type(MessageListResponse, message, path=["response"]) @@ -243,7 +246,9 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: @pytest.mark.skip() @parametrize def test_raw_response_list(self, client: Agentex) -> None: - response = client.messages.with_raw_response.list() + response = client.messages.with_raw_response.list( + task_id="task_id", + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -253,7 +258,9 @@ def test_raw_response_list(self, client: Agentex) -> None: @pytest.mark.skip() @parametrize def test_streaming_response_list(self, client: Agentex) -> None: - with client.messages.with_streaming_response.list() as response: + with client.messages.with_streaming_response.list( + task_id="task_id", + ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -477,13 +484,16 @@ async def test_path_params_update(self, async_client: AsyncAgentex) -> None: @pytest.mark.skip() @parametrize async def test_method_list(self, async_client: AsyncAgentex) -> None: - message = await async_client.messages.list() + message = await async_client.messages.list( + task_id="task_id", + ) assert_matches_type(MessageListResponse, message, path=["response"]) @pytest.mark.skip() @parametrize async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.list( + task_id="task_id", limit=0, ) assert_matches_type(MessageListResponse, message, path=["response"]) @@ -491,7 +501,9 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> @pytest.mark.skip() @parametrize async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: - response = await async_client.messages.with_raw_response.list() + response = await async_client.messages.with_raw_response.list( + task_id="task_id", + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -501,7 +513,9 @@ async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: @pytest.mark.skip() @parametrize async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: - async with async_client.messages.with_streaming_response.list() as response: + async with async_client.messages.with_streaming_response.list( + task_id="task_id", + ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" diff --git a/tests/api_resources/test_tasks.py b/tests/api_resources/test_tasks.py index bf10c953..97f20453 100644 --- a/tests/api_resources/test_tasks.py +++ b/tests/api_resources/test_tasks.py @@ -9,7 +9,7 @@ from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type -from agentex.types import Task, TaskListResponse, TaskDeleteByNameResponse +from agentex.types import Task, TaskListResponse, TaskDeleteResponse, TaskDeleteByNameResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -93,7 +93,7 @@ def test_method_delete(self, client: Agentex) -> None: task = client.tasks.delete( "task_id", ) - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -105,7 +105,7 @@ def test_raw_response_delete(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -117,7 +117,7 @@ def test_streaming_response_delete(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -377,7 +377,7 @@ async def test_method_delete(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.delete( "task_id", ) - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -389,7 +389,7 @@ async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -401,7 +401,7 @@ async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskDeleteResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True From d73748b2472c59b2121a4414f60f54c239dfd75a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 29 Jul 2025 06:02:42 +0000 Subject: [PATCH 0058/1108] feat(api): manual updates --- .stats.yml | 2 +- api.md | 18 ++++++++----- src/agentex/resources/agents.py | 19 +++++++------ src/agentex/resources/tasks.py | 19 +++++++------ src/agentex/types/__init__.py | 5 +--- .../types/agent_delete_by_name_response.py | 11 -------- src/agentex/types/agent_delete_response.py | 11 -------- src/agentex/types/shared/__init__.py | 3 +++ .../delete_response.py} | 6 ++--- .../types/task_delete_by_name_response.py | 11 -------- tests/api_resources/test_agents.py | 27 +++++++++---------- tests/api_resources/test_tasks.py | 27 ++++++++++--------- 12 files changed, 64 insertions(+), 95 deletions(-) delete mode 100644 src/agentex/types/agent_delete_by_name_response.py delete mode 100644 src/agentex/types/agent_delete_response.py create mode 100644 src/agentex/types/shared/__init__.py rename src/agentex/types/{task_delete_response.py => shared/delete_response.py} (54%) delete mode 100644 src/agentex/types/task_delete_by_name_response.py diff --git a/.stats.yml b/.stats.yml index ab941275..6b2efc6a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-733bcb26b2f53abaac835267d630274ca18eba7726350b65fa2a74cc490908c1.yml openapi_spec_hash: f9a141a82a0b19bde31d6ea48ae4d6d6 -config_hash: 7c1f6794a184ee175dd94f2f7c2b496b +config_hash: f6ec6016df1ff072b5b60cdf7b438361 diff --git a/api.md b/api.md index 29e04573..0f9d0c99 100644 --- a/api.md +++ b/api.md @@ -1,3 +1,9 @@ +# Shared Types + +```python +from agentex.types import DeleteResponse +``` + # Agents Types: @@ -17,8 +23,6 @@ from agentex.types import ( ToolRequestDelta, ToolResponseDelta, AgentListResponse, - AgentDeleteResponse, - AgentDeleteByNameResponse, ) ``` @@ -26,8 +30,8 @@ Methods: - client.agents.retrieve(agent_id) -> Agent - client.agents.list(\*\*params) -> AgentListResponse -- client.agents.delete(agent_id) -> AgentDeleteResponse -- client.agents.delete_by_name(agent_name) -> AgentDeleteByNameResponse +- client.agents.delete(agent_id) -> DeleteResponse +- client.agents.delete_by_name(agent_name) -> DeleteResponse - client.agents.retrieve_by_name(agent_name) -> Agent - client.agents.rpc(agent_id, \*\*params) -> AgentRpcResponse - client.agents.rpc_by_name(agent_name, \*\*params) -> AgentRpcResponse @@ -37,15 +41,15 @@ Methods: Types: ```python -from agentex.types import Task, TaskListResponse, TaskDeleteResponse, TaskDeleteByNameResponse +from agentex.types import Task, TaskListResponse ``` Methods: - client.tasks.retrieve(task_id) -> Task - client.tasks.list() -> TaskListResponse -- client.tasks.delete(task_id) -> TaskDeleteResponse -- client.tasks.delete_by_name(task_name) -> TaskDeleteByNameResponse +- client.tasks.delete(task_id) -> DeleteResponse +- client.tasks.delete_by_name(task_name) -> DeleteResponse - client.tasks.retrieve_by_name(task_name) -> Task - client.tasks.stream_events(task_id) -> object - client.tasks.stream_events_by_name(task_name) -> object diff --git a/src/agentex/resources/agents.py b/src/agentex/resources/agents.py index 31e332df..ea563f91 100644 --- a/src/agentex/resources/agents.py +++ b/src/agentex/resources/agents.py @@ -22,8 +22,7 @@ from .._base_client import make_request_options from ..types.agent_rpc_response import AgentRpcResponse from ..types.agent_list_response import AgentListResponse -from ..types.agent_delete_response import AgentDeleteResponse -from ..types.agent_delete_by_name_response import AgentDeleteByNameResponse +from ..types.shared.delete_response import DeleteResponse __all__ = ["AgentsResource", "AsyncAgentsResource"] @@ -128,7 +127,7 @@ def delete( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> AgentDeleteResponse: + ) -> DeleteResponse: """ Delete an agent by its unique ID. @@ -148,7 +147,7 @@ def delete( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AgentDeleteResponse, + cast_to=DeleteResponse, ) def delete_by_name( @@ -161,7 +160,7 @@ def delete_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> AgentDeleteByNameResponse: + ) -> DeleteResponse: """ Delete an agent by its unique name. @@ -181,7 +180,7 @@ def delete_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AgentDeleteByNameResponse, + cast_to=DeleteResponse, ) def retrieve_by_name( @@ -414,7 +413,7 @@ async def delete( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> AgentDeleteResponse: + ) -> DeleteResponse: """ Delete an agent by its unique ID. @@ -434,7 +433,7 @@ async def delete( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AgentDeleteResponse, + cast_to=DeleteResponse, ) async def delete_by_name( @@ -447,7 +446,7 @@ async def delete_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> AgentDeleteByNameResponse: + ) -> DeleteResponse: """ Delete an agent by its unique name. @@ -467,7 +466,7 @@ async def delete_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=AgentDeleteByNameResponse, + cast_to=DeleteResponse, ) async def retrieve_by_name( diff --git a/src/agentex/resources/tasks.py b/src/agentex/resources/tasks.py index 8bd17670..a7021c62 100644 --- a/src/agentex/resources/tasks.py +++ b/src/agentex/resources/tasks.py @@ -17,8 +17,7 @@ from ..types.task import Task from .._base_client import make_request_options from ..types.task_list_response import TaskListResponse -from ..types.task_delete_response import TaskDeleteResponse -from ..types.task_delete_by_name_response import TaskDeleteByNameResponse +from ..types.shared.delete_response import DeleteResponse __all__ = ["TasksResource", "AsyncTasksResource"] @@ -105,7 +104,7 @@ def delete( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> TaskDeleteResponse: + ) -> DeleteResponse: """ Delete a task by its unique ID. @@ -125,7 +124,7 @@ def delete( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=TaskDeleteResponse, + cast_to=DeleteResponse, ) def delete_by_name( @@ -138,7 +137,7 @@ def delete_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> TaskDeleteByNameResponse: + ) -> DeleteResponse: """ Delete a task by its unique name. @@ -158,7 +157,7 @@ def delete_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=TaskDeleteByNameResponse, + cast_to=DeleteResponse, ) def retrieve_by_name( @@ -347,7 +346,7 @@ async def delete( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> TaskDeleteResponse: + ) -> DeleteResponse: """ Delete a task by its unique ID. @@ -367,7 +366,7 @@ async def delete( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=TaskDeleteResponse, + cast_to=DeleteResponse, ) async def delete_by_name( @@ -380,7 +379,7 @@ async def delete_by_name( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> TaskDeleteByNameResponse: + ) -> DeleteResponse: """ Delete a task by its unique name. @@ -400,7 +399,7 @@ async def delete_by_name( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=TaskDeleteByNameResponse, + cast_to=DeleteResponse, ) async def retrieve_by_name( diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 2a42dd8f..7e45d120 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -7,6 +7,7 @@ from .agent import Agent as Agent from .event import Event as Event from .state import State as State +from .shared import DeleteResponse as DeleteResponse from .acp_type import AcpType as AcpType from .data_delta import DataDelta as DataDelta from .text_delta import TextDelta as TextDelta @@ -40,10 +41,8 @@ from .task_message_update import TaskMessageUpdate as TaskMessageUpdate from .tool_response_delta import ToolResponseDelta as ToolResponseDelta from .tracker_list_params import TrackerListParams as TrackerListParams -from .task_delete_response import TaskDeleteResponse as TaskDeleteResponse from .task_message_content import TaskMessageContent as TaskMessageContent from .tool_request_content import ToolRequestContent as ToolRequestContent -from .agent_delete_response import AgentDeleteResponse as AgentDeleteResponse from .message_create_params import MessageCreateParams as MessageCreateParams from .message_list_response import MessageListResponse as MessageListResponse from .message_update_params import MessageUpdateParams as MessageUpdateParams @@ -54,5 +53,3 @@ from .task_message_content_param import TaskMessageContentParam as TaskMessageContentParam from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam -from .task_delete_by_name_response import TaskDeleteByNameResponse as TaskDeleteByNameResponse -from .agent_delete_by_name_response import AgentDeleteByNameResponse as AgentDeleteByNameResponse diff --git a/src/agentex/types/agent_delete_by_name_response.py b/src/agentex/types/agent_delete_by_name_response.py deleted file mode 100644 index 66e67abc..00000000 --- a/src/agentex/types/agent_delete_by_name_response.py +++ /dev/null @@ -1,11 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .._models import BaseModel - -__all__ = ["AgentDeleteByNameResponse"] - - -class AgentDeleteByNameResponse(BaseModel): - id: str - - message: str diff --git a/src/agentex/types/agent_delete_response.py b/src/agentex/types/agent_delete_response.py deleted file mode 100644 index fbf4ab7f..00000000 --- a/src/agentex/types/agent_delete_response.py +++ /dev/null @@ -1,11 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .._models import BaseModel - -__all__ = ["AgentDeleteResponse"] - - -class AgentDeleteResponse(BaseModel): - id: str - - message: str diff --git a/src/agentex/types/shared/__init__.py b/src/agentex/types/shared/__init__.py new file mode 100644 index 00000000..b4526793 --- /dev/null +++ b/src/agentex/types/shared/__init__.py @@ -0,0 +1,3 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .delete_response import DeleteResponse as DeleteResponse diff --git a/src/agentex/types/task_delete_response.py b/src/agentex/types/shared/delete_response.py similarity index 54% rename from src/agentex/types/task_delete_response.py rename to src/agentex/types/shared/delete_response.py index eb68aadb..7b72bdf5 100644 --- a/src/agentex/types/task_delete_response.py +++ b/src/agentex/types/shared/delete_response.py @@ -1,11 +1,11 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from .._models import BaseModel +from ..._models import BaseModel -__all__ = ["TaskDeleteResponse"] +__all__ = ["DeleteResponse"] -class TaskDeleteResponse(BaseModel): +class DeleteResponse(BaseModel): id: str message: str diff --git a/src/agentex/types/task_delete_by_name_response.py b/src/agentex/types/task_delete_by_name_response.py deleted file mode 100644 index 297cff96..00000000 --- a/src/agentex/types/task_delete_by_name_response.py +++ /dev/null @@ -1,11 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .._models import BaseModel - -__all__ = ["TaskDeleteByNameResponse"] - - -class TaskDeleteByNameResponse(BaseModel): - id: str - - message: str diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index 0293268f..8656542d 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -13,9 +13,8 @@ Agent, AgentRpcResponse, AgentListResponse, - AgentDeleteResponse, - AgentDeleteByNameResponse, ) +from agentex.types.shared import DeleteResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -107,7 +106,7 @@ def test_method_delete(self, client: Agentex) -> None: agent = client.agents.delete( "agent_id", ) - assert_matches_type(AgentDeleteResponse, agent, path=["response"]) + assert_matches_type(DeleteResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -119,7 +118,7 @@ def test_raw_response_delete(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(AgentDeleteResponse, agent, path=["response"]) + assert_matches_type(DeleteResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -131,7 +130,7 @@ def test_streaming_response_delete(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(AgentDeleteResponse, agent, path=["response"]) + assert_matches_type(DeleteResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -149,7 +148,7 @@ def test_method_delete_by_name(self, client: Agentex) -> None: agent = client.agents.delete_by_name( "agent_name", ) - assert_matches_type(AgentDeleteByNameResponse, agent, path=["response"]) + assert_matches_type(DeleteResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -161,7 +160,7 @@ def test_raw_response_delete_by_name(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(AgentDeleteByNameResponse, agent, path=["response"]) + assert_matches_type(DeleteResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +172,7 @@ def test_streaming_response_delete_by_name(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = response.parse() - assert_matches_type(AgentDeleteByNameResponse, agent, path=["response"]) + assert_matches_type(DeleteResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -447,7 +446,7 @@ async def test_method_delete(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.delete( "agent_id", ) - assert_matches_type(AgentDeleteResponse, agent, path=["response"]) + assert_matches_type(DeleteResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -459,7 +458,7 @@ async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AgentDeleteResponse, agent, path=["response"]) + assert_matches_type(DeleteResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -471,7 +470,7 @@ async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AgentDeleteResponse, agent, path=["response"]) + assert_matches_type(DeleteResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True @@ -489,7 +488,7 @@ async def test_method_delete_by_name(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.delete_by_name( "agent_name", ) - assert_matches_type(AgentDeleteByNameResponse, agent, path=["response"]) + assert_matches_type(DeleteResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -501,7 +500,7 @@ async def test_raw_response_delete_by_name(self, async_client: AsyncAgentex) -> assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AgentDeleteByNameResponse, agent, path=["response"]) + assert_matches_type(DeleteResponse, agent, path=["response"]) @pytest.mark.skip() @parametrize @@ -513,7 +512,7 @@ async def test_streaming_response_delete_by_name(self, async_client: AsyncAgente assert response.http_request.headers.get("X-Stainless-Lang") == "python" agent = await response.parse() - assert_matches_type(AgentDeleteByNameResponse, agent, path=["response"]) + assert_matches_type(DeleteResponse, agent, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_tasks.py b/tests/api_resources/test_tasks.py index 97f20453..a46e5edc 100644 --- a/tests/api_resources/test_tasks.py +++ b/tests/api_resources/test_tasks.py @@ -9,7 +9,8 @@ from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type -from agentex.types import Task, TaskListResponse, TaskDeleteResponse, TaskDeleteByNameResponse +from agentex.types import Task, TaskListResponse +from agentex.types.shared import DeleteResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -93,7 +94,7 @@ def test_method_delete(self, client: Agentex) -> None: task = client.tasks.delete( "task_id", ) - assert_matches_type(TaskDeleteResponse, task, path=["response"]) + assert_matches_type(DeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -105,7 +106,7 @@ def test_raw_response_delete(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(TaskDeleteResponse, task, path=["response"]) + assert_matches_type(DeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -117,7 +118,7 @@ def test_streaming_response_delete(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(TaskDeleteResponse, task, path=["response"]) + assert_matches_type(DeleteResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -135,7 +136,7 @@ def test_method_delete_by_name(self, client: Agentex) -> None: task = client.tasks.delete_by_name( "task_name", ) - assert_matches_type(TaskDeleteByNameResponse, task, path=["response"]) + assert_matches_type(DeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -147,7 +148,7 @@ def test_raw_response_delete_by_name(self, client: Agentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(TaskDeleteByNameResponse, task, path=["response"]) + assert_matches_type(DeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -159,7 +160,7 @@ def test_streaming_response_delete_by_name(self, client: Agentex) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(TaskDeleteByNameResponse, task, path=["response"]) + assert_matches_type(DeleteResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -377,7 +378,7 @@ async def test_method_delete(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.delete( "task_id", ) - assert_matches_type(TaskDeleteResponse, task, path=["response"]) + assert_matches_type(DeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -389,7 +390,7 @@ async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(TaskDeleteResponse, task, path=["response"]) + assert_matches_type(DeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -401,7 +402,7 @@ async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(TaskDeleteResponse, task, path=["response"]) + assert_matches_type(DeleteResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -419,7 +420,7 @@ async def test_method_delete_by_name(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.delete_by_name( "task_name", ) - assert_matches_type(TaskDeleteByNameResponse, task, path=["response"]) + assert_matches_type(DeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -431,7 +432,7 @@ async def test_raw_response_delete_by_name(self, async_client: AsyncAgentex) -> assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(TaskDeleteByNameResponse, task, path=["response"]) + assert_matches_type(DeleteResponse, task, path=["response"]) @pytest.mark.skip() @parametrize @@ -443,7 +444,7 @@ async def test_streaming_response_delete_by_name(self, async_client: AsyncAgente assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(TaskDeleteByNameResponse, task, path=["response"]) + assert_matches_type(DeleteResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True From 003f4c2ec00636039d78eee47344f8a0ae7e4da8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 29 Jul 2025 08:24:41 +0000 Subject: [PATCH 0059/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6b2efc6a..b5dd2d61 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-733bcb26b2f53abaac835267d630274ca18eba7726350b65fa2a74cc490908c1.yml -openapi_spec_hash: f9a141a82a0b19bde31d6ea48ae4d6d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-e1efa8c7e58d81f5c0242d4ea49ac7637b5d455d10a40f217b1183c229b65dd2.yml +openapi_spec_hash: 8fdf7cace40fb14a765c4e09c2d5bb95 config_hash: f6ec6016df1ff072b5b60cdf7b438361 From 402fe7fdf2fa534799ec4aa59121e030a87c334f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 30 Jul 2025 06:39:09 +0000 Subject: [PATCH 0060/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 9aa540f7..7f58a508 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.2.4" + ".": "0.2.5" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 3e66c529..2cd427f6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.2.4" +version = "0.2.5" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index c0d16f84..d59e7af8 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.2.4" # x-release-please-version +__version__ = "0.2.5" # x-release-please-version From 0acf067ab3373a31246c7a0deeb748c7b1f78c06 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 30 Jul 2025 17:03:56 +0000 Subject: [PATCH 0061/1108] feat(client): support file upload requests --- src/agentex/_base_client.py | 5 ++++- src/agentex/_files.py | 8 ++++---- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/src/agentex/_base_client.py b/src/agentex/_base_client.py index 0cc1fbb7..67eb675d 100644 --- a/src/agentex/_base_client.py +++ b/src/agentex/_base_client.py @@ -532,7 +532,10 @@ def _build_request( is_body_allowed = options.method.lower() != "get" if is_body_allowed: - kwargs["json"] = json_data if is_given(json_data) else None + if isinstance(json_data, bytes): + kwargs["content"] = json_data + else: + kwargs["json"] = json_data if is_given(json_data) else None kwargs["files"] = files else: headers.pop("Content-Type", None) diff --git a/src/agentex/_files.py b/src/agentex/_files.py index 715cc207..cc14c14f 100644 --- a/src/agentex/_files.py +++ b/src/agentex/_files.py @@ -69,12 +69,12 @@ def _transform_file(file: FileTypes) -> HttpxFileTypes: return file if is_tuple_t(file): - return (file[0], _read_file_content(file[1]), *file[2:]) + return (file[0], read_file_content(file[1]), *file[2:]) raise TypeError(f"Expected file types input to be a FileContent type or to be a tuple") -def _read_file_content(file: FileContent) -> HttpxFileContent: +def read_file_content(file: FileContent) -> HttpxFileContent: if isinstance(file, os.PathLike): return pathlib.Path(file).read_bytes() return file @@ -111,12 +111,12 @@ async def _async_transform_file(file: FileTypes) -> HttpxFileTypes: return file if is_tuple_t(file): - return (file[0], await _async_read_file_content(file[1]), *file[2:]) + return (file[0], await async_read_file_content(file[1]), *file[2:]) raise TypeError(f"Expected file types input to be a FileContent type or to be a tuple") -async def _async_read_file_content(file: FileContent) -> HttpxFileContent: +async def async_read_file_content(file: FileContent) -> HttpxFileContent: if isinstance(file, os.PathLike): return await anyio.Path(file).read_bytes() From 45c312cb51fa735d90d61162306649babaa1885f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 31 Jul 2025 02:24:46 +0000 Subject: [PATCH 0062/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index b5dd2d61..6b2efc6a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-e1efa8c7e58d81f5c0242d4ea49ac7637b5d455d10a40f217b1183c229b65dd2.yml -openapi_spec_hash: 8fdf7cace40fb14a765c4e09c2d5bb95 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-733bcb26b2f53abaac835267d630274ca18eba7726350b65fa2a74cc490908c1.yml +openapi_spec_hash: f9a141a82a0b19bde31d6ea48ae4d6d6 config_hash: f6ec6016df1ff072b5b60cdf7b438361 From aca6a11027db13fef076acfe4d3e4d7ca00c752f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 31 Jul 2025 03:24:46 +0000 Subject: [PATCH 0063/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6b2efc6a..b5dd2d61 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-733bcb26b2f53abaac835267d630274ca18eba7726350b65fa2a74cc490908c1.yml -openapi_spec_hash: f9a141a82a0b19bde31d6ea48ae4d6d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-e1efa8c7e58d81f5c0242d4ea49ac7637b5d455d10a40f217b1183c229b65dd2.yml +openapi_spec_hash: 8fdf7cace40fb14a765c4e09c2d5bb95 config_hash: f6ec6016df1ff072b5b60cdf7b438361 From 2ae05ae0315a9d386beb40b5d3c02a27a4c4ee05 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 31 Jul 2025 22:24:48 +0000 Subject: [PATCH 0064/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index b5dd2d61..6b2efc6a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-e1efa8c7e58d81f5c0242d4ea49ac7637b5d455d10a40f217b1183c229b65dd2.yml -openapi_spec_hash: 8fdf7cace40fb14a765c4e09c2d5bb95 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-733bcb26b2f53abaac835267d630274ca18eba7726350b65fa2a74cc490908c1.yml +openapi_spec_hash: f9a141a82a0b19bde31d6ea48ae4d6d6 config_hash: f6ec6016df1ff072b5b60cdf7b438361 From 54ce1c7263be3b92e81b96bd97bca0f33f4dac98 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 1 Aug 2025 00:18:07 +0000 Subject: [PATCH 0065/1108] feat(api): add query params to tasks.list allows listing tasks with filters on agent ID and name --- .stats.yml | 4 +- api.md | 2 +- src/agentex/resources/tasks.py | 58 +++++++++++++++++++++++++-- src/agentex/types/__init__.py | 1 + src/agentex/types/task_list_params.py | 14 +++++++ tests/api_resources/test_tasks.py | 18 +++++++++ 6 files changed, 90 insertions(+), 7 deletions(-) create mode 100644 src/agentex/types/task_list_params.py diff --git a/.stats.yml b/.stats.yml index 6b2efc6a..61c7aed6 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-733bcb26b2f53abaac835267d630274ca18eba7726350b65fa2a74cc490908c1.yml -openapi_spec_hash: f9a141a82a0b19bde31d6ea48ae4d6d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-02d466207a009c07fd85804f8917889d1d5503dc600ff6d7fd78ef29cf9e93a1.yml +openapi_spec_hash: e40b923e3cd395998d53a4d5830ab7e4 config_hash: f6ec6016df1ff072b5b60cdf7b438361 diff --git a/api.md b/api.md index 0f9d0c99..9c135dfa 100644 --- a/api.md +++ b/api.md @@ -47,7 +47,7 @@ from agentex.types import Task, TaskListResponse Methods: - client.tasks.retrieve(task_id) -> Task -- client.tasks.list() -> TaskListResponse +- client.tasks.list(\*\*params) -> TaskListResponse - client.tasks.delete(task_id) -> DeleteResponse - client.tasks.delete_by_name(task_name) -> DeleteResponse - client.tasks.retrieve_by_name(task_name) -> Task diff --git a/src/agentex/resources/tasks.py b/src/agentex/resources/tasks.py index a7021c62..5a28465b 100644 --- a/src/agentex/resources/tasks.py +++ b/src/agentex/resources/tasks.py @@ -2,9 +2,13 @@ from __future__ import annotations +from typing import Optional + import httpx +from ..types import task_list_params from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property from .._resource import SyncAPIResource, AsyncAPIResource from .._response import ( @@ -78,6 +82,8 @@ def retrieve( def list( self, *, + agent_id: Optional[str] | NotGiven = NOT_GIVEN, + agent_name: Optional[str] | NotGiven = NOT_GIVEN, # 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, @@ -85,11 +91,32 @@ def list( extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, ) -> TaskListResponse: - """List all tasks.""" + """ + List all tasks. + + Args: + 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 + """ return self._get( "/tasks", options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "agent_id": agent_id, + "agent_name": agent_name, + }, + task_list_params.TaskListParams, + ), ), cast_to=TaskListResponse, ) @@ -320,6 +347,8 @@ async def retrieve( async def list( self, *, + agent_id: Optional[str] | NotGiven = NOT_GIVEN, + agent_name: Optional[str] | NotGiven = NOT_GIVEN, # 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, @@ -327,11 +356,32 @@ async def list( extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, ) -> TaskListResponse: - """List all tasks.""" + """ + List all tasks. + + Args: + 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 + """ return await self._get( "/tasks", options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "agent_id": agent_id, + "agent_name": agent_name, + }, + task_list_params.TaskListParams, + ), ), cast_to=TaskListResponse, ) diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 7e45d120..b502cb00 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -19,6 +19,7 @@ from .agent_rpc_params import AgentRpcParams as AgentRpcParams from .agent_rpc_result import AgentRpcResult as AgentRpcResult from .span_list_params import SpanListParams as SpanListParams +from .task_list_params import TaskListParams as TaskListParams from .agent_list_params import AgentListParams as AgentListParams from .event_list_params import EventListParams as EventListParams from .state_list_params import StateListParams as StateListParams diff --git a/src/agentex/types/task_list_params.py b/src/agentex/types/task_list_params.py new file mode 100644 index 00000000..f8bc3364 --- /dev/null +++ b/src/agentex/types/task_list_params.py @@ -0,0 +1,14 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import TypedDict + +__all__ = ["TaskListParams"] + + +class TaskListParams(TypedDict, total=False): + agent_id: Optional[str] + + agent_name: Optional[str] diff --git a/tests/api_resources/test_tasks.py b/tests/api_resources/test_tasks.py index a46e5edc..6a707050 100644 --- a/tests/api_resources/test_tasks.py +++ b/tests/api_resources/test_tasks.py @@ -66,6 +66,15 @@ def test_method_list(self, client: Agentex) -> None: task = client.tasks.list() assert_matches_type(TaskListResponse, task, path=["response"]) + @pytest.mark.skip() + @parametrize + def test_method_list_with_all_params(self, client: Agentex) -> None: + task = client.tasks.list( + agent_id="agent_id", + agent_name="agent_name", + ) + assert_matches_type(TaskListResponse, task, path=["response"]) + @pytest.mark.skip() @parametrize def test_raw_response_list(self, client: Agentex) -> None: @@ -350,6 +359,15 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.list() assert_matches_type(TaskListResponse, task, path=["response"]) + @pytest.mark.skip() + @parametrize + async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: + task = await async_client.tasks.list( + agent_id="agent_id", + agent_name="agent_name", + ) + assert_matches_type(TaskListResponse, task, path=["response"]) + @pytest.mark.skip() @parametrize async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: From ca148c8c462fe110e8def03772562c54dcafb9ed Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 1 Aug 2025 00:24:50 +0000 Subject: [PATCH 0066/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 61c7aed6..49a26dc2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-02d466207a009c07fd85804f8917889d1d5503dc600ff6d7fd78ef29cf9e93a1.yml -openapi_spec_hash: e40b923e3cd395998d53a4d5830ab7e4 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4e1c137bb7977db9f224437bef638a51725f001c0453a1adf273cf3b920a7120.yml +openapi_spec_hash: f52a4797cadb597b32615460abec2b18 config_hash: f6ec6016df1ff072b5b60cdf7b438361 From 2b3a1e326998d782871e86fb93e3dcbec4952eb6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 1 Aug 2025 15:01:33 +0000 Subject: [PATCH 0067/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 7f58a508..c4f43cf1 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.2.5" + ".": "0.2.6" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 2cd427f6..8d14a14a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.2.5" +version = "0.2.6" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index d59e7af8..4cde5e3d 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.2.5" # x-release-please-version +__version__ = "0.2.6" # x-release-please-version From 5cb9e05b22cce355453efb46ab8cad4fdce06a95 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 5 Aug 2025 01:24:50 +0000 Subject: [PATCH 0068/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 49a26dc2..2ba4a19a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4e1c137bb7977db9f224437bef638a51725f001c0453a1adf273cf3b920a7120.yml -openapi_spec_hash: f52a4797cadb597b32615460abec2b18 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-02d466207a009c07fd85804f8917889d1d5503dc600ff6d7fd78ef29cf9e93a1.yml +openapi_spec_hash: d5b82c1fa3dad3ad3df8d5f0abdd8194 config_hash: f6ec6016df1ff072b5b60cdf7b438361 From d5cba8b83b6d4f867e45bf52dd2b7bbb87fde04c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 5 Aug 2025 11:24:09 +0000 Subject: [PATCH 0069/1108] chore(internal): fix ruff target version --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 8d14a14a..e1686162 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -159,7 +159,7 @@ reportPrivateUsage = false [tool.ruff] line-length = 120 output-format = "grouped" -target-version = "py37" +target-version = "py38" [tool.ruff.format] docstring-code-format = true From 7db808cce15f89afe0cfa1d39ee384c5c9735422 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 6 Aug 2025 22:24:55 +0000 Subject: [PATCH 0070/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2ba4a19a..41996c6e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-02d466207a009c07fd85804f8917889d1d5503dc600ff6d7fd78ef29cf9e93a1.yml -openapi_spec_hash: d5b82c1fa3dad3ad3df8d5f0abdd8194 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-8b3b6f15ce45de5f37e06ff39e0f5ad7862a40f2c0b51400071fb3a6d7e6fdf1.yml +openapi_spec_hash: 359ef3a86944f0224ce521b47aa915e0 config_hash: f6ec6016df1ff072b5b60cdf7b438361 From 1cd2b90177ab130f3f9e0f73aa9dc903ca9c29a3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 8 Aug 2025 00:24:58 +0000 Subject: [PATCH 0071/1108] feat(api): api update --- .stats.yml | 4 ++-- src/agentex/types/agent.py | 7 +++++++ 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 41996c6e..5be0dc77 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-8b3b6f15ce45de5f37e06ff39e0f5ad7862a40f2c0b51400071fb3a6d7e6fdf1.yml -openapi_spec_hash: 359ef3a86944f0224ce521b47aa915e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-431952b0bdddd9af38a775d036be228bb49af7333376af65102db222d9afe9b1.yml +openapi_spec_hash: 7c0aee10dad14901d7aaf0f79a86d6af config_hash: f6ec6016df1ff072b5b60cdf7b438361 diff --git a/src/agentex/types/agent.py b/src/agentex/types/agent.py index d339ece1..9b921e8e 100644 --- a/src/agentex/types/agent.py +++ b/src/agentex/types/agent.py @@ -1,6 +1,7 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. from typing import Optional +from datetime import datetime from typing_extensions import Literal from .._models import BaseModel @@ -16,12 +17,18 @@ class Agent(BaseModel): acp_type: AcpType """The type of the ACP Server (Either sync or agentic)""" + created_at: datetime + """The timestamp when the agent was created""" + description: str """The description of the action.""" name: str """The unique name of the agent.""" + updated_at: datetime + """The timestamp when the agent was last updated""" + status: Optional[Literal["Pending", "Building", "Ready", "Failed", "Unknown"]] = None """The status of the action, indicating if it's building, ready, failed, etc.""" From 63691b6cf675ca344754e297ef0be53267053727 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 8 Aug 2025 02:25:03 +0000 Subject: [PATCH 0072/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5be0dc77..bb7b1e4b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-431952b0bdddd9af38a775d036be228bb49af7333376af65102db222d9afe9b1.yml -openapi_spec_hash: 7c0aee10dad14901d7aaf0f79a86d6af +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-11c219d0dae35b66569db21fd732cd50c3d164b742facbfd85272eb438698f60.yml +openapi_spec_hash: 83fa098892b79c51e8772ef87ac901da config_hash: f6ec6016df1ff072b5b60cdf7b438361 From 4e84b84bf81a67ed2c64d3962f7eb4e3414feff5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 8 Aug 2025 03:25:09 +0000 Subject: [PATCH 0073/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index bb7b1e4b..5be0dc77 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-11c219d0dae35b66569db21fd732cd50c3d164b742facbfd85272eb438698f60.yml -openapi_spec_hash: 83fa098892b79c51e8772ef87ac901da +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-431952b0bdddd9af38a775d036be228bb49af7333376af65102db222d9afe9b1.yml +openapi_spec_hash: 7c0aee10dad14901d7aaf0f79a86d6af config_hash: f6ec6016df1ff072b5b60cdf7b438361 From bebbb2227bea2d90d2bb4adfefd285877f9239f0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 8 Aug 2025 04:20:23 +0000 Subject: [PATCH 0074/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index c4f43cf1..c65ff3cc 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.2.6" + ".": "0.2.7" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index e1686162..53a00f77 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.2.6" +version = "0.2.7" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 4cde5e3d..371c9c6e 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.2.6" # x-release-please-version +__version__ = "0.2.7" # x-release-please-version From 17064b81bcde38d7a94bcdefd9c48569dc79a620 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 8 Aug 2025 15:25:13 +0000 Subject: [PATCH 0075/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5be0dc77..bb7b1e4b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-431952b0bdddd9af38a775d036be228bb49af7333376af65102db222d9afe9b1.yml -openapi_spec_hash: 7c0aee10dad14901d7aaf0f79a86d6af +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-11c219d0dae35b66569db21fd732cd50c3d164b742facbfd85272eb438698f60.yml +openapi_spec_hash: 83fa098892b79c51e8772ef87ac901da config_hash: f6ec6016df1ff072b5b60cdf7b438361 From 75c426740480b2e4ec275d64009976eec3253f57 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 8 Aug 2025 17:58:10 +0000 Subject: [PATCH 0076/1108] chore: update @stainless-api/prism-cli to v5.15.0 --- scripts/mock | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/mock b/scripts/mock index d2814ae6..0b28f6ea 100755 --- a/scripts/mock +++ b/scripts/mock @@ -21,7 +21,7 @@ echo "==> Starting mock server with URL ${URL}" # Run prism mock on the given spec if [ "$1" == "--daemon" ]; then - npm exec --package=@stainless-api/prism-cli@5.8.5 -- prism mock "$URL" &> .prism.log & + npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock "$URL" &> .prism.log & # Wait for server to come online echo -n "Waiting for server" @@ -37,5 +37,5 @@ if [ "$1" == "--daemon" ]; then echo else - npm exec --package=@stainless-api/prism-cli@5.8.5 -- prism mock "$URL" + npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock "$URL" fi From 9950d2d4372de882ec113e0d5d287491eebe3f0d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 8 Aug 2025 21:23:17 +0000 Subject: [PATCH 0077/1108] chore(internal): update comment in script --- scripts/test | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/test b/scripts/test index 2b878456..dbeda2d2 100755 --- a/scripts/test +++ b/scripts/test @@ -43,7 +43,7 @@ elif ! prism_is_running ; then echo -e "To run the server, pass in the path or url of your OpenAPI" echo -e "spec to the prism command:" echo - echo -e " \$ ${YELLOW}npm exec --package=@stoplight/prism-cli@~5.3.2 -- prism mock path/to/your.openapi.yml${NC}" + echo -e " \$ ${YELLOW}npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock path/to/your.openapi.yml${NC}" echo exit 1 From 0ed5577f2e1ae4fc25ecbbce2a48a5bb3bfbddb7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 9 Aug 2025 19:04:17 +0000 Subject: [PATCH 0078/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index c65ff3cc..69af4c2c 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.2.7" + ".": "0.2.8" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 53a00f77..0b14a888 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.2.7" +version = "0.2.8" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 371c9c6e..a0211692 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.2.7" # x-release-please-version +__version__ = "0.2.8" # x-release-please-version From 7575470c83cae9f61919c8e9308e96b06c2390f1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 11 Aug 2025 16:18:08 +0000 Subject: [PATCH 0079/1108] chore(internal): update test skipping reason --- tests/api_resources/messages/test_batch.py | 24 ++--- tests/api_resources/test_agents.py | 120 ++++++++++----------- tests/api_resources/test_events.py | 32 +++--- tests/api_resources/test_messages.py | 68 ++++++------ tests/api_resources/test_spans.py | 68 ++++++------ tests/api_resources/test_states.py | 76 ++++++------- tests/api_resources/test_tasks.py | 112 +++++++++---------- tests/api_resources/test_tracker.py | 52 ++++----- 8 files changed, 276 insertions(+), 276 deletions(-) diff --git a/tests/api_resources/messages/test_batch.py b/tests/api_resources/messages/test_batch.py index 9ad5e59c..a572047a 100644 --- a/tests/api_resources/messages/test_batch.py +++ b/tests/api_resources/messages/test_batch.py @@ -17,7 +17,7 @@ class TestBatch: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_create(self, client: Agentex) -> None: batch = client.messages.batch.create( @@ -31,7 +31,7 @@ def test_method_create(self, client: Agentex) -> None: ) assert_matches_type(BatchCreateResponse, batch, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_create(self, client: Agentex) -> None: response = client.messages.batch.with_raw_response.create( @@ -49,7 +49,7 @@ def test_raw_response_create(self, client: Agentex) -> None: batch = response.parse() assert_matches_type(BatchCreateResponse, batch, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_create(self, client: Agentex) -> None: with client.messages.batch.with_streaming_response.create( @@ -69,7 +69,7 @@ def test_streaming_response_create(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_update(self, client: Agentex) -> None: batch = client.messages.batch.update( @@ -83,7 +83,7 @@ def test_method_update(self, client: Agentex) -> None: ) assert_matches_type(BatchUpdateResponse, batch, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_update(self, client: Agentex) -> None: response = client.messages.batch.with_raw_response.update( @@ -101,7 +101,7 @@ def test_raw_response_update(self, client: Agentex) -> None: batch = response.parse() assert_matches_type(BatchUpdateResponse, batch, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_update(self, client: Agentex) -> None: with client.messages.batch.with_streaming_response.update( @@ -127,7 +127,7 @@ class TestAsyncBatch: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncAgentex) -> None: batch = await async_client.messages.batch.create( @@ -141,7 +141,7 @@ async def test_method_create(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(BatchCreateResponse, batch, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncAgentex) -> None: response = await async_client.messages.batch.with_raw_response.create( @@ -159,7 +159,7 @@ async def test_raw_response_create(self, async_client: AsyncAgentex) -> None: batch = await response.parse() assert_matches_type(BatchCreateResponse, batch, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncAgentex) -> None: async with async_client.messages.batch.with_streaming_response.create( @@ -179,7 +179,7 @@ async def test_streaming_response_create(self, async_client: AsyncAgentex) -> No assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_update(self, async_client: AsyncAgentex) -> None: batch = await async_client.messages.batch.update( @@ -193,7 +193,7 @@ async def test_method_update(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(BatchUpdateResponse, batch, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: response = await async_client.messages.batch.with_raw_response.update( @@ -211,7 +211,7 @@ async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: batch = await response.parse() assert_matches_type(BatchUpdateResponse, batch, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_update(self, async_client: AsyncAgentex) -> None: async with async_client.messages.batch.with_streaming_response.update( diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index 8656542d..7ef11072 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -22,7 +22,7 @@ class TestAgents: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_retrieve(self, client: Agentex) -> None: agent = client.agents.retrieve( @@ -30,7 +30,7 @@ def test_method_retrieve(self, client: Agentex) -> None: ) assert_matches_type(Agent, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.agents.with_raw_response.retrieve( @@ -42,7 +42,7 @@ def test_raw_response_retrieve(self, client: Agentex) -> None: agent = response.parse() assert_matches_type(Agent, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.agents.with_streaming_response.retrieve( @@ -56,7 +56,7 @@ def test_streaming_response_retrieve(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): @@ -64,13 +64,13 @@ def test_path_params_retrieve(self, client: Agentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_list(self, client: Agentex) -> None: agent = client.agents.list() assert_matches_type(AgentListResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_list_with_all_params(self, client: Agentex) -> None: agent = client.agents.list( @@ -78,7 +78,7 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: ) assert_matches_type(AgentListResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_list(self, client: Agentex) -> None: response = client.agents.with_raw_response.list() @@ -88,7 +88,7 @@ def test_raw_response_list(self, client: Agentex) -> None: agent = response.parse() assert_matches_type(AgentListResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_list(self, client: Agentex) -> None: with client.agents.with_streaming_response.list() as response: @@ -100,7 +100,7 @@ def test_streaming_response_list(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_delete(self, client: Agentex) -> None: agent = client.agents.delete( @@ -108,7 +108,7 @@ def test_method_delete(self, client: Agentex) -> None: ) assert_matches_type(DeleteResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_delete(self, client: Agentex) -> None: response = client.agents.with_raw_response.delete( @@ -120,7 +120,7 @@ def test_raw_response_delete(self, client: Agentex) -> None: agent = response.parse() assert_matches_type(DeleteResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_delete(self, client: Agentex) -> None: with client.agents.with_streaming_response.delete( @@ -134,7 +134,7 @@ def test_streaming_response_delete(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_delete(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): @@ -142,7 +142,7 @@ def test_path_params_delete(self, client: Agentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_delete_by_name(self, client: Agentex) -> None: agent = client.agents.delete_by_name( @@ -150,7 +150,7 @@ def test_method_delete_by_name(self, client: Agentex) -> None: ) assert_matches_type(DeleteResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_delete_by_name(self, client: Agentex) -> None: response = client.agents.with_raw_response.delete_by_name( @@ -162,7 +162,7 @@ def test_raw_response_delete_by_name(self, client: Agentex) -> None: agent = response.parse() assert_matches_type(DeleteResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_delete_by_name(self, client: Agentex) -> None: with client.agents.with_streaming_response.delete_by_name( @@ -176,7 +176,7 @@ def test_streaming_response_delete_by_name(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_delete_by_name(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): @@ -184,7 +184,7 @@ def test_path_params_delete_by_name(self, client: Agentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_retrieve_by_name(self, client: Agentex) -> None: agent = client.agents.retrieve_by_name( @@ -192,7 +192,7 @@ def test_method_retrieve_by_name(self, client: Agentex) -> None: ) assert_matches_type(Agent, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve_by_name(self, client: Agentex) -> None: response = client.agents.with_raw_response.retrieve_by_name( @@ -204,7 +204,7 @@ def test_raw_response_retrieve_by_name(self, client: Agentex) -> None: agent = response.parse() assert_matches_type(Agent, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve_by_name(self, client: Agentex) -> None: with client.agents.with_streaming_response.retrieve_by_name( @@ -218,7 +218,7 @@ def test_streaming_response_retrieve_by_name(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_retrieve_by_name(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): @@ -226,7 +226,7 @@ def test_path_params_retrieve_by_name(self, client: Agentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_rpc(self, client: Agentex) -> None: agent = client.agents.rpc( @@ -236,7 +236,7 @@ def test_method_rpc(self, client: Agentex) -> None: ) assert_matches_type(AgentRpcResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_rpc_with_all_params(self, client: Agentex) -> None: agent = client.agents.rpc( @@ -251,7 +251,7 @@ def test_method_rpc_with_all_params(self, client: Agentex) -> None: ) assert_matches_type(AgentRpcResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_rpc(self, client: Agentex) -> None: response = client.agents.with_raw_response.rpc( @@ -265,7 +265,7 @@ def test_raw_response_rpc(self, client: Agentex) -> None: agent = response.parse() assert_matches_type(AgentRpcResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_rpc(self, client: Agentex) -> None: with client.agents.with_streaming_response.rpc( @@ -281,7 +281,7 @@ def test_streaming_response_rpc(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_rpc(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): @@ -291,7 +291,7 @@ def test_path_params_rpc(self, client: Agentex) -> None: params={}, ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_rpc_by_name(self, client: Agentex) -> None: agent = client.agents.rpc_by_name( @@ -301,7 +301,7 @@ def test_method_rpc_by_name(self, client: Agentex) -> None: ) assert_matches_type(AgentRpcResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_rpc_by_name_with_all_params(self, client: Agentex) -> None: agent = client.agents.rpc_by_name( @@ -316,7 +316,7 @@ def test_method_rpc_by_name_with_all_params(self, client: Agentex) -> None: ) assert_matches_type(AgentRpcResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_rpc_by_name(self, client: Agentex) -> None: response = client.agents.with_raw_response.rpc_by_name( @@ -330,7 +330,7 @@ def test_raw_response_rpc_by_name(self, client: Agentex) -> None: agent = response.parse() assert_matches_type(AgentRpcResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_rpc_by_name(self, client: Agentex) -> None: with client.agents.with_streaming_response.rpc_by_name( @@ -346,7 +346,7 @@ def test_streaming_response_rpc_by_name(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_rpc_by_name(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): @@ -362,7 +362,7 @@ class TestAsyncAgents: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.retrieve( @@ -370,7 +370,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(Agent, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.agents.with_raw_response.retrieve( @@ -382,7 +382,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: agent = await response.parse() assert_matches_type(Agent, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.agents.with_streaming_response.retrieve( @@ -396,7 +396,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): @@ -404,13 +404,13 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.list() assert_matches_type(AgentListResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.list( @@ -418,7 +418,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> ) assert_matches_type(AgentListResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: response = await async_client.agents.with_raw_response.list() @@ -428,7 +428,7 @@ async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: agent = await response.parse() assert_matches_type(AgentListResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: async with async_client.agents.with_streaming_response.list() as response: @@ -440,7 +440,7 @@ async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.delete( @@ -448,7 +448,7 @@ async def test_method_delete(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(DeleteResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: response = await async_client.agents.with_raw_response.delete( @@ -460,7 +460,7 @@ async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: agent = await response.parse() assert_matches_type(DeleteResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> None: async with async_client.agents.with_streaming_response.delete( @@ -474,7 +474,7 @@ async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> No assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): @@ -482,7 +482,7 @@ async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_delete_by_name(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.delete_by_name( @@ -490,7 +490,7 @@ async def test_method_delete_by_name(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(DeleteResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_delete_by_name(self, async_client: AsyncAgentex) -> None: response = await async_client.agents.with_raw_response.delete_by_name( @@ -502,7 +502,7 @@ async def test_raw_response_delete_by_name(self, async_client: AsyncAgentex) -> agent = await response.parse() assert_matches_type(DeleteResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_delete_by_name(self, async_client: AsyncAgentex) -> None: async with async_client.agents.with_streaming_response.delete_by_name( @@ -516,7 +516,7 @@ async def test_streaming_response_delete_by_name(self, async_client: AsyncAgente assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_delete_by_name(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): @@ -524,7 +524,7 @@ async def test_path_params_delete_by_name(self, async_client: AsyncAgentex) -> N "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_retrieve_by_name(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.retrieve_by_name( @@ -532,7 +532,7 @@ async def test_method_retrieve_by_name(self, async_client: AsyncAgentex) -> None ) assert_matches_type(Agent, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve_by_name(self, async_client: AsyncAgentex) -> None: response = await async_client.agents.with_raw_response.retrieve_by_name( @@ -544,7 +544,7 @@ async def test_raw_response_retrieve_by_name(self, async_client: AsyncAgentex) - agent = await response.parse() assert_matches_type(Agent, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve_by_name(self, async_client: AsyncAgentex) -> None: async with async_client.agents.with_streaming_response.retrieve_by_name( @@ -558,7 +558,7 @@ async def test_streaming_response_retrieve_by_name(self, async_client: AsyncAgen assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_retrieve_by_name(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): @@ -566,7 +566,7 @@ async def test_path_params_retrieve_by_name(self, async_client: AsyncAgentex) -> "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_rpc(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.rpc( @@ -576,7 +576,7 @@ async def test_method_rpc(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(AgentRpcResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_rpc_with_all_params(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.rpc( @@ -591,7 +591,7 @@ async def test_method_rpc_with_all_params(self, async_client: AsyncAgentex) -> N ) assert_matches_type(AgentRpcResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_rpc(self, async_client: AsyncAgentex) -> None: response = await async_client.agents.with_raw_response.rpc( @@ -605,7 +605,7 @@ async def test_raw_response_rpc(self, async_client: AsyncAgentex) -> None: agent = await response.parse() assert_matches_type(AgentRpcResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_rpc(self, async_client: AsyncAgentex) -> None: async with async_client.agents.with_streaming_response.rpc( @@ -621,7 +621,7 @@ async def test_streaming_response_rpc(self, async_client: AsyncAgentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_rpc(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): @@ -631,7 +631,7 @@ async def test_path_params_rpc(self, async_client: AsyncAgentex) -> None: params={}, ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_rpc_by_name(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.rpc_by_name( @@ -641,7 +641,7 @@ async def test_method_rpc_by_name(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(AgentRpcResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_rpc_by_name_with_all_params(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.rpc_by_name( @@ -656,7 +656,7 @@ async def test_method_rpc_by_name_with_all_params(self, async_client: AsyncAgent ) assert_matches_type(AgentRpcResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_rpc_by_name(self, async_client: AsyncAgentex) -> None: response = await async_client.agents.with_raw_response.rpc_by_name( @@ -670,7 +670,7 @@ async def test_raw_response_rpc_by_name(self, async_client: AsyncAgentex) -> Non agent = await response.parse() assert_matches_type(AgentRpcResponse, agent, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_rpc_by_name(self, async_client: AsyncAgentex) -> None: async with async_client.agents.with_streaming_response.rpc_by_name( @@ -686,7 +686,7 @@ async def test_streaming_response_rpc_by_name(self, async_client: AsyncAgentex) assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_rpc_by_name(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_name` but received ''"): diff --git a/tests/api_resources/test_events.py b/tests/api_resources/test_events.py index c11c6c94..fad95592 100644 --- a/tests/api_resources/test_events.py +++ b/tests/api_resources/test_events.py @@ -17,7 +17,7 @@ class TestEvents: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_retrieve(self, client: Agentex) -> None: event = client.events.retrieve( @@ -25,7 +25,7 @@ def test_method_retrieve(self, client: Agentex) -> None: ) assert_matches_type(Event, event, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.events.with_raw_response.retrieve( @@ -37,7 +37,7 @@ def test_raw_response_retrieve(self, client: Agentex) -> None: event = response.parse() assert_matches_type(Event, event, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.events.with_streaming_response.retrieve( @@ -51,7 +51,7 @@ def test_streaming_response_retrieve(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `event_id` but received ''"): @@ -59,7 +59,7 @@ def test_path_params_retrieve(self, client: Agentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_list(self, client: Agentex) -> None: event = client.events.list( @@ -68,7 +68,7 @@ def test_method_list(self, client: Agentex) -> None: ) assert_matches_type(EventListResponse, event, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_list_with_all_params(self, client: Agentex) -> None: event = client.events.list( @@ -79,7 +79,7 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: ) assert_matches_type(EventListResponse, event, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_list(self, client: Agentex) -> None: response = client.events.with_raw_response.list( @@ -92,7 +92,7 @@ def test_raw_response_list(self, client: Agentex) -> None: event = response.parse() assert_matches_type(EventListResponse, event, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_list(self, client: Agentex) -> None: with client.events.with_streaming_response.list( @@ -113,7 +113,7 @@ class TestAsyncEvents: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: event = await async_client.events.retrieve( @@ -121,7 +121,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(Event, event, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.events.with_raw_response.retrieve( @@ -133,7 +133,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: event = await response.parse() assert_matches_type(Event, event, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.events.with_streaming_response.retrieve( @@ -147,7 +147,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `event_id` but received ''"): @@ -155,7 +155,7 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncAgentex) -> None: event = await async_client.events.list( @@ -164,7 +164,7 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(EventListResponse, event, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: event = await async_client.events.list( @@ -175,7 +175,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> ) assert_matches_type(EventListResponse, event, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: response = await async_client.events.with_raw_response.list( @@ -188,7 +188,7 @@ async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: event = await response.parse() assert_matches_type(EventListResponse, event, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: async with async_client.events.with_streaming_response.list( diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py index eb0af8cd..457d3e24 100644 --- a/tests/api_resources/test_messages.py +++ b/tests/api_resources/test_messages.py @@ -20,7 +20,7 @@ class TestMessages: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_create(self, client: Agentex) -> None: message = client.messages.create( @@ -33,7 +33,7 @@ def test_method_create(self, client: Agentex) -> None: ) assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_create_with_all_params(self, client: Agentex) -> None: message = client.messages.create( @@ -57,7 +57,7 @@ def test_method_create_with_all_params(self, client: Agentex) -> None: ) assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_create(self, client: Agentex) -> None: response = client.messages.with_raw_response.create( @@ -74,7 +74,7 @@ def test_raw_response_create(self, client: Agentex) -> None: message = response.parse() assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_create(self, client: Agentex) -> None: with client.messages.with_streaming_response.create( @@ -93,7 +93,7 @@ def test_streaming_response_create(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_retrieve(self, client: Agentex) -> None: message = client.messages.retrieve( @@ -101,7 +101,7 @@ def test_method_retrieve(self, client: Agentex) -> None: ) assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.messages.with_raw_response.retrieve( @@ -113,7 +113,7 @@ def test_raw_response_retrieve(self, client: Agentex) -> None: message = response.parse() assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.messages.with_streaming_response.retrieve( @@ -127,7 +127,7 @@ def test_streaming_response_retrieve(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"): @@ -135,7 +135,7 @@ def test_path_params_retrieve(self, client: Agentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_update(self, client: Agentex) -> None: message = client.messages.update( @@ -149,7 +149,7 @@ def test_method_update(self, client: Agentex) -> None: ) assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_update_with_all_params(self, client: Agentex) -> None: message = client.messages.update( @@ -174,7 +174,7 @@ def test_method_update_with_all_params(self, client: Agentex) -> None: ) assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_update(self, client: Agentex) -> None: response = client.messages.with_raw_response.update( @@ -192,7 +192,7 @@ def test_raw_response_update(self, client: Agentex) -> None: message = response.parse() assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_update(self, client: Agentex) -> None: with client.messages.with_streaming_response.update( @@ -212,7 +212,7 @@ def test_streaming_response_update(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_update(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"): @@ -226,7 +226,7 @@ def test_path_params_update(self, client: Agentex) -> None: task_id="task_id", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_list(self, client: Agentex) -> None: message = client.messages.list( @@ -234,7 +234,7 @@ def test_method_list(self, client: Agentex) -> None: ) assert_matches_type(MessageListResponse, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_list_with_all_params(self, client: Agentex) -> None: message = client.messages.list( @@ -243,7 +243,7 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: ) assert_matches_type(MessageListResponse, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_list(self, client: Agentex) -> None: response = client.messages.with_raw_response.list( @@ -255,7 +255,7 @@ def test_raw_response_list(self, client: Agentex) -> None: message = response.parse() assert_matches_type(MessageListResponse, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_list(self, client: Agentex) -> None: with client.messages.with_streaming_response.list( @@ -275,7 +275,7 @@ class TestAsyncMessages: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.create( @@ -288,7 +288,7 @@ async def test_method_create(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_create_with_all_params(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.create( @@ -312,7 +312,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncAgentex) - ) assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncAgentex) -> None: response = await async_client.messages.with_raw_response.create( @@ -329,7 +329,7 @@ async def test_raw_response_create(self, async_client: AsyncAgentex) -> None: message = await response.parse() assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncAgentex) -> None: async with async_client.messages.with_streaming_response.create( @@ -348,7 +348,7 @@ async def test_streaming_response_create(self, async_client: AsyncAgentex) -> No assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.retrieve( @@ -356,7 +356,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.messages.with_raw_response.retrieve( @@ -368,7 +368,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: message = await response.parse() assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.messages.with_streaming_response.retrieve( @@ -382,7 +382,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"): @@ -390,7 +390,7 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_update(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.update( @@ -404,7 +404,7 @@ async def test_method_update(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_update_with_all_params(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.update( @@ -429,7 +429,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncAgentex) - ) assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: response = await async_client.messages.with_raw_response.update( @@ -447,7 +447,7 @@ async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: message = await response.parse() assert_matches_type(TaskMessage, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_update(self, async_client: AsyncAgentex) -> None: async with async_client.messages.with_streaming_response.update( @@ -467,7 +467,7 @@ async def test_streaming_response_update(self, async_client: AsyncAgentex) -> No assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_update(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"): @@ -481,7 +481,7 @@ async def test_path_params_update(self, async_client: AsyncAgentex) -> None: task_id="task_id", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.list( @@ -489,7 +489,7 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(MessageListResponse, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: message = await async_client.messages.list( @@ -498,7 +498,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> ) assert_matches_type(MessageListResponse, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: response = await async_client.messages.with_raw_response.list( @@ -510,7 +510,7 @@ async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: message = await response.parse() assert_matches_type(MessageListResponse, message, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: async with async_client.messages.with_streaming_response.list( diff --git a/tests/api_resources/test_spans.py b/tests/api_resources/test_spans.py index 344b7779..b9c9b168 100644 --- a/tests/api_resources/test_spans.py +++ b/tests/api_resources/test_spans.py @@ -18,7 +18,7 @@ class TestSpans: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_create(self, client: Agentex) -> None: span = client.spans.create( @@ -28,7 +28,7 @@ def test_method_create(self, client: Agentex) -> None: ) assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_create_with_all_params(self, client: Agentex) -> None: span = client.spans.create( @@ -44,7 +44,7 @@ def test_method_create_with_all_params(self, client: Agentex) -> None: ) assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_create(self, client: Agentex) -> None: response = client.spans.with_raw_response.create( @@ -58,7 +58,7 @@ def test_raw_response_create(self, client: Agentex) -> None: span = response.parse() assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_create(self, client: Agentex) -> None: with client.spans.with_streaming_response.create( @@ -74,7 +74,7 @@ def test_streaming_response_create(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_retrieve(self, client: Agentex) -> None: span = client.spans.retrieve( @@ -82,7 +82,7 @@ def test_method_retrieve(self, client: Agentex) -> None: ) assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.spans.with_raw_response.retrieve( @@ -94,7 +94,7 @@ def test_raw_response_retrieve(self, client: Agentex) -> None: span = response.parse() assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.spans.with_streaming_response.retrieve( @@ -108,7 +108,7 @@ def test_streaming_response_retrieve(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `span_id` but received ''"): @@ -116,7 +116,7 @@ def test_path_params_retrieve(self, client: Agentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_update(self, client: Agentex) -> None: span = client.spans.update( @@ -124,7 +124,7 @@ def test_method_update(self, client: Agentex) -> None: ) assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_update_with_all_params(self, client: Agentex) -> None: span = client.spans.update( @@ -140,7 +140,7 @@ def test_method_update_with_all_params(self, client: Agentex) -> None: ) assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_update(self, client: Agentex) -> None: response = client.spans.with_raw_response.update( @@ -152,7 +152,7 @@ def test_raw_response_update(self, client: Agentex) -> None: span = response.parse() assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_update(self, client: Agentex) -> None: with client.spans.with_streaming_response.update( @@ -166,7 +166,7 @@ def test_streaming_response_update(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_update(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `span_id` but received ''"): @@ -174,13 +174,13 @@ def test_path_params_update(self, client: Agentex) -> None: span_id="", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_list(self, client: Agentex) -> None: span = client.spans.list() assert_matches_type(SpanListResponse, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_list_with_all_params(self, client: Agentex) -> None: span = client.spans.list( @@ -188,7 +188,7 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: ) assert_matches_type(SpanListResponse, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_list(self, client: Agentex) -> None: response = client.spans.with_raw_response.list() @@ -198,7 +198,7 @@ def test_raw_response_list(self, client: Agentex) -> None: span = response.parse() assert_matches_type(SpanListResponse, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_list(self, client: Agentex) -> None: with client.spans.with_streaming_response.list() as response: @@ -216,7 +216,7 @@ class TestAsyncSpans: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.create( @@ -226,7 +226,7 @@ async def test_method_create(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_create_with_all_params(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.create( @@ -242,7 +242,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncAgentex) - ) assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncAgentex) -> None: response = await async_client.spans.with_raw_response.create( @@ -256,7 +256,7 @@ async def test_raw_response_create(self, async_client: AsyncAgentex) -> None: span = await response.parse() assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncAgentex) -> None: async with async_client.spans.with_streaming_response.create( @@ -272,7 +272,7 @@ async def test_streaming_response_create(self, async_client: AsyncAgentex) -> No assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.retrieve( @@ -280,7 +280,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.spans.with_raw_response.retrieve( @@ -292,7 +292,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: span = await response.parse() assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.spans.with_streaming_response.retrieve( @@ -306,7 +306,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `span_id` but received ''"): @@ -314,7 +314,7 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_update(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.update( @@ -322,7 +322,7 @@ async def test_method_update(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_update_with_all_params(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.update( @@ -338,7 +338,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncAgentex) - ) assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: response = await async_client.spans.with_raw_response.update( @@ -350,7 +350,7 @@ async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: span = await response.parse() assert_matches_type(Span, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_update(self, async_client: AsyncAgentex) -> None: async with async_client.spans.with_streaming_response.update( @@ -364,7 +364,7 @@ async def test_streaming_response_update(self, async_client: AsyncAgentex) -> No assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_update(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `span_id` but received ''"): @@ -372,13 +372,13 @@ async def test_path_params_update(self, async_client: AsyncAgentex) -> None: span_id="", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.list() assert_matches_type(SpanListResponse, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.list( @@ -386,7 +386,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> ) assert_matches_type(SpanListResponse, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: response = await async_client.spans.with_raw_response.list() @@ -396,7 +396,7 @@ async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: span = await response.parse() assert_matches_type(SpanListResponse, span, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: async with async_client.spans.with_streaming_response.list() as response: diff --git a/tests/api_resources/test_states.py b/tests/api_resources/test_states.py index 8e4fc62c..b23ff49a 100644 --- a/tests/api_resources/test_states.py +++ b/tests/api_resources/test_states.py @@ -17,7 +17,7 @@ class TestStates: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_create(self, client: Agentex) -> None: state = client.states.create( @@ -27,7 +27,7 @@ def test_method_create(self, client: Agentex) -> None: ) assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_create(self, client: Agentex) -> None: response = client.states.with_raw_response.create( @@ -41,7 +41,7 @@ def test_raw_response_create(self, client: Agentex) -> None: state = response.parse() assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_create(self, client: Agentex) -> None: with client.states.with_streaming_response.create( @@ -57,7 +57,7 @@ def test_streaming_response_create(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_retrieve(self, client: Agentex) -> None: state = client.states.retrieve( @@ -65,7 +65,7 @@ def test_method_retrieve(self, client: Agentex) -> None: ) assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.states.with_raw_response.retrieve( @@ -77,7 +77,7 @@ def test_raw_response_retrieve(self, client: Agentex) -> None: state = response.parse() assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.states.with_streaming_response.retrieve( @@ -91,7 +91,7 @@ def test_streaming_response_retrieve(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): @@ -99,7 +99,7 @@ def test_path_params_retrieve(self, client: Agentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_update(self, client: Agentex) -> None: state = client.states.update( @@ -110,7 +110,7 @@ def test_method_update(self, client: Agentex) -> None: ) assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_update(self, client: Agentex) -> None: response = client.states.with_raw_response.update( @@ -125,7 +125,7 @@ def test_raw_response_update(self, client: Agentex) -> None: state = response.parse() assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_update(self, client: Agentex) -> None: with client.states.with_streaming_response.update( @@ -142,7 +142,7 @@ def test_streaming_response_update(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_update(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): @@ -153,13 +153,13 @@ def test_path_params_update(self, client: Agentex) -> None: task_id="task_id", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_list(self, client: Agentex) -> None: state = client.states.list() assert_matches_type(StateListResponse, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_list_with_all_params(self, client: Agentex) -> None: state = client.states.list( @@ -168,7 +168,7 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: ) assert_matches_type(StateListResponse, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_list(self, client: Agentex) -> None: response = client.states.with_raw_response.list() @@ -178,7 +178,7 @@ def test_raw_response_list(self, client: Agentex) -> None: state = response.parse() assert_matches_type(StateListResponse, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_list(self, client: Agentex) -> None: with client.states.with_streaming_response.list() as response: @@ -190,7 +190,7 @@ def test_streaming_response_list(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_delete(self, client: Agentex) -> None: state = client.states.delete( @@ -198,7 +198,7 @@ def test_method_delete(self, client: Agentex) -> None: ) assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_delete(self, client: Agentex) -> None: response = client.states.with_raw_response.delete( @@ -210,7 +210,7 @@ def test_raw_response_delete(self, client: Agentex) -> None: state = response.parse() assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_delete(self, client: Agentex) -> None: with client.states.with_streaming_response.delete( @@ -224,7 +224,7 @@ def test_streaming_response_delete(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_delete(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): @@ -238,7 +238,7 @@ class TestAsyncStates: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncAgentex) -> None: state = await async_client.states.create( @@ -248,7 +248,7 @@ async def test_method_create(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncAgentex) -> None: response = await async_client.states.with_raw_response.create( @@ -262,7 +262,7 @@ async def test_raw_response_create(self, async_client: AsyncAgentex) -> None: state = await response.parse() assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncAgentex) -> None: async with async_client.states.with_streaming_response.create( @@ -278,7 +278,7 @@ async def test_streaming_response_create(self, async_client: AsyncAgentex) -> No assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: state = await async_client.states.retrieve( @@ -286,7 +286,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.states.with_raw_response.retrieve( @@ -298,7 +298,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: state = await response.parse() assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.states.with_streaming_response.retrieve( @@ -312,7 +312,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): @@ -320,7 +320,7 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_update(self, async_client: AsyncAgentex) -> None: state = await async_client.states.update( @@ -331,7 +331,7 @@ async def test_method_update(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: response = await async_client.states.with_raw_response.update( @@ -346,7 +346,7 @@ async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: state = await response.parse() assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_update(self, async_client: AsyncAgentex) -> None: async with async_client.states.with_streaming_response.update( @@ -363,7 +363,7 @@ async def test_streaming_response_update(self, async_client: AsyncAgentex) -> No assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_update(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): @@ -374,13 +374,13 @@ async def test_path_params_update(self, async_client: AsyncAgentex) -> None: task_id="task_id", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncAgentex) -> None: state = await async_client.states.list() assert_matches_type(StateListResponse, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: state = await async_client.states.list( @@ -389,7 +389,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> ) assert_matches_type(StateListResponse, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: response = await async_client.states.with_raw_response.list() @@ -399,7 +399,7 @@ async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: state = await response.parse() assert_matches_type(StateListResponse, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: async with async_client.states.with_streaming_response.list() as response: @@ -411,7 +411,7 @@ async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncAgentex) -> None: state = await async_client.states.delete( @@ -419,7 +419,7 @@ async def test_method_delete(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: response = await async_client.states.with_raw_response.delete( @@ -431,7 +431,7 @@ async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: state = await response.parse() assert_matches_type(State, state, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> None: async with async_client.states.with_streaming_response.delete( @@ -445,7 +445,7 @@ async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> No assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `state_id` but received ''"): diff --git a/tests/api_resources/test_tasks.py b/tests/api_resources/test_tasks.py index 6a707050..ac858a80 100644 --- a/tests/api_resources/test_tasks.py +++ b/tests/api_resources/test_tasks.py @@ -18,7 +18,7 @@ class TestTasks: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_retrieve(self, client: Agentex) -> None: task = client.tasks.retrieve( @@ -26,7 +26,7 @@ def test_method_retrieve(self, client: Agentex) -> None: ) assert_matches_type(Task, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.tasks.with_raw_response.retrieve( @@ -38,7 +38,7 @@ def test_raw_response_retrieve(self, client: Agentex) -> None: task = response.parse() assert_matches_type(Task, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.tasks.with_streaming_response.retrieve( @@ -52,7 +52,7 @@ def test_streaming_response_retrieve(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): @@ -60,13 +60,13 @@ def test_path_params_retrieve(self, client: Agentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_list(self, client: Agentex) -> None: task = client.tasks.list() assert_matches_type(TaskListResponse, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_list_with_all_params(self, client: Agentex) -> None: task = client.tasks.list( @@ -75,7 +75,7 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: ) assert_matches_type(TaskListResponse, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_list(self, client: Agentex) -> None: response = client.tasks.with_raw_response.list() @@ -85,7 +85,7 @@ def test_raw_response_list(self, client: Agentex) -> None: task = response.parse() assert_matches_type(TaskListResponse, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_list(self, client: Agentex) -> None: with client.tasks.with_streaming_response.list() as response: @@ -97,7 +97,7 @@ def test_streaming_response_list(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_delete(self, client: Agentex) -> None: task = client.tasks.delete( @@ -105,7 +105,7 @@ def test_method_delete(self, client: Agentex) -> None: ) assert_matches_type(DeleteResponse, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_delete(self, client: Agentex) -> None: response = client.tasks.with_raw_response.delete( @@ -117,7 +117,7 @@ def test_raw_response_delete(self, client: Agentex) -> None: task = response.parse() assert_matches_type(DeleteResponse, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_delete(self, client: Agentex) -> None: with client.tasks.with_streaming_response.delete( @@ -131,7 +131,7 @@ def test_streaming_response_delete(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_delete(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): @@ -139,7 +139,7 @@ def test_path_params_delete(self, client: Agentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_delete_by_name(self, client: Agentex) -> None: task = client.tasks.delete_by_name( @@ -147,7 +147,7 @@ def test_method_delete_by_name(self, client: Agentex) -> None: ) assert_matches_type(DeleteResponse, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_delete_by_name(self, client: Agentex) -> None: response = client.tasks.with_raw_response.delete_by_name( @@ -159,7 +159,7 @@ def test_raw_response_delete_by_name(self, client: Agentex) -> None: task = response.parse() assert_matches_type(DeleteResponse, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_delete_by_name(self, client: Agentex) -> None: with client.tasks.with_streaming_response.delete_by_name( @@ -173,7 +173,7 @@ def test_streaming_response_delete_by_name(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_delete_by_name(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): @@ -181,7 +181,7 @@ def test_path_params_delete_by_name(self, client: Agentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_retrieve_by_name(self, client: Agentex) -> None: task = client.tasks.retrieve_by_name( @@ -189,7 +189,7 @@ def test_method_retrieve_by_name(self, client: Agentex) -> None: ) assert_matches_type(Task, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve_by_name(self, client: Agentex) -> None: response = client.tasks.with_raw_response.retrieve_by_name( @@ -201,7 +201,7 @@ def test_raw_response_retrieve_by_name(self, client: Agentex) -> None: task = response.parse() assert_matches_type(Task, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve_by_name(self, client: Agentex) -> None: with client.tasks.with_streaming_response.retrieve_by_name( @@ -215,7 +215,7 @@ def test_streaming_response_retrieve_by_name(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_retrieve_by_name(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): @@ -223,7 +223,7 @@ def test_path_params_retrieve_by_name(self, client: Agentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_stream_events(self, client: Agentex) -> None: task_stream = client.tasks.stream_events( @@ -231,7 +231,7 @@ def test_method_stream_events(self, client: Agentex) -> None: ) task_stream.response.close() - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_stream_events(self, client: Agentex) -> None: response = client.tasks.with_raw_response.stream_events( @@ -242,7 +242,7 @@ def test_raw_response_stream_events(self, client: Agentex) -> None: stream = response.parse() stream.close() - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_stream_events(self, client: Agentex) -> None: with client.tasks.with_streaming_response.stream_events( @@ -256,7 +256,7 @@ def test_streaming_response_stream_events(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_stream_events(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): @@ -264,7 +264,7 @@ def test_path_params_stream_events(self, client: Agentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_stream_events_by_name(self, client: Agentex) -> None: task_stream = client.tasks.stream_events_by_name( @@ -272,7 +272,7 @@ def test_method_stream_events_by_name(self, client: Agentex) -> None: ) task_stream.response.close() - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_stream_events_by_name(self, client: Agentex) -> None: response = client.tasks.with_raw_response.stream_events_by_name( @@ -283,7 +283,7 @@ def test_raw_response_stream_events_by_name(self, client: Agentex) -> None: stream = response.parse() stream.close() - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_stream_events_by_name(self, client: Agentex) -> None: with client.tasks.with_streaming_response.stream_events_by_name( @@ -297,7 +297,7 @@ def test_streaming_response_stream_events_by_name(self, client: Agentex) -> None assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_stream_events_by_name(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): @@ -311,7 +311,7 @@ class TestAsyncTasks: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.retrieve( @@ -319,7 +319,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(Task, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.retrieve( @@ -331,7 +331,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: task = await response.parse() assert_matches_type(Task, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.retrieve( @@ -345,7 +345,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): @@ -353,13 +353,13 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.list() assert_matches_type(TaskListResponse, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.list( @@ -368,7 +368,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> ) assert_matches_type(TaskListResponse, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.list() @@ -378,7 +378,7 @@ async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: task = await response.parse() assert_matches_type(TaskListResponse, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.list() as response: @@ -390,7 +390,7 @@ async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.delete( @@ -398,7 +398,7 @@ async def test_method_delete(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(DeleteResponse, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.delete( @@ -410,7 +410,7 @@ async def test_raw_response_delete(self, async_client: AsyncAgentex) -> None: task = await response.parse() assert_matches_type(DeleteResponse, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.delete( @@ -424,7 +424,7 @@ async def test_streaming_response_delete(self, async_client: AsyncAgentex) -> No assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): @@ -432,7 +432,7 @@ async def test_path_params_delete(self, async_client: AsyncAgentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_delete_by_name(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.delete_by_name( @@ -440,7 +440,7 @@ async def test_method_delete_by_name(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(DeleteResponse, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_delete_by_name(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.delete_by_name( @@ -452,7 +452,7 @@ async def test_raw_response_delete_by_name(self, async_client: AsyncAgentex) -> task = await response.parse() assert_matches_type(DeleteResponse, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_delete_by_name(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.delete_by_name( @@ -466,7 +466,7 @@ async def test_streaming_response_delete_by_name(self, async_client: AsyncAgente assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_delete_by_name(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): @@ -474,7 +474,7 @@ async def test_path_params_delete_by_name(self, async_client: AsyncAgentex) -> N "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_retrieve_by_name(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.retrieve_by_name( @@ -482,7 +482,7 @@ async def test_method_retrieve_by_name(self, async_client: AsyncAgentex) -> None ) assert_matches_type(Task, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve_by_name(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.retrieve_by_name( @@ -494,7 +494,7 @@ async def test_raw_response_retrieve_by_name(self, async_client: AsyncAgentex) - task = await response.parse() assert_matches_type(Task, task, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve_by_name(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.retrieve_by_name( @@ -508,7 +508,7 @@ async def test_streaming_response_retrieve_by_name(self, async_client: AsyncAgen assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_retrieve_by_name(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): @@ -516,7 +516,7 @@ async def test_path_params_retrieve_by_name(self, async_client: AsyncAgentex) -> "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_stream_events(self, async_client: AsyncAgentex) -> None: task_stream = await async_client.tasks.stream_events( @@ -524,7 +524,7 @@ async def test_method_stream_events(self, async_client: AsyncAgentex) -> None: ) await task_stream.response.aclose() - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_stream_events(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.stream_events( @@ -535,7 +535,7 @@ async def test_raw_response_stream_events(self, async_client: AsyncAgentex) -> N stream = await response.parse() await stream.close() - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_stream_events(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.stream_events( @@ -549,7 +549,7 @@ async def test_streaming_response_stream_events(self, async_client: AsyncAgentex assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_stream_events(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): @@ -557,7 +557,7 @@ async def test_path_params_stream_events(self, async_client: AsyncAgentex) -> No "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_stream_events_by_name(self, async_client: AsyncAgentex) -> None: task_stream = await async_client.tasks.stream_events_by_name( @@ -565,7 +565,7 @@ async def test_method_stream_events_by_name(self, async_client: AsyncAgentex) -> ) await task_stream.response.aclose() - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_stream_events_by_name(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.stream_events_by_name( @@ -576,7 +576,7 @@ async def test_raw_response_stream_events_by_name(self, async_client: AsyncAgent stream = await response.parse() await stream.close() - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_stream_events_by_name(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.stream_events_by_name( @@ -590,7 +590,7 @@ async def test_streaming_response_stream_events_by_name(self, async_client: Asyn assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_stream_events_by_name(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): diff --git a/tests/api_resources/test_tracker.py b/tests/api_resources/test_tracker.py index 11366810..431508c3 100644 --- a/tests/api_resources/test_tracker.py +++ b/tests/api_resources/test_tracker.py @@ -17,7 +17,7 @@ class TestTracker: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_retrieve(self, client: Agentex) -> None: tracker = client.tracker.retrieve( @@ -25,7 +25,7 @@ def test_method_retrieve(self, client: Agentex) -> None: ) assert_matches_type(AgentTaskTracker, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.tracker.with_raw_response.retrieve( @@ -37,7 +37,7 @@ def test_raw_response_retrieve(self, client: Agentex) -> None: tracker = response.parse() assert_matches_type(AgentTaskTracker, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.tracker.with_streaming_response.retrieve( @@ -51,7 +51,7 @@ def test_streaming_response_retrieve(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `tracker_id` but received ''"): @@ -59,7 +59,7 @@ def test_path_params_retrieve(self, client: Agentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_update(self, client: Agentex) -> None: tracker = client.tracker.update( @@ -67,7 +67,7 @@ def test_method_update(self, client: Agentex) -> None: ) assert_matches_type(AgentTaskTracker, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_update_with_all_params(self, client: Agentex) -> None: tracker = client.tracker.update( @@ -78,7 +78,7 @@ def test_method_update_with_all_params(self, client: Agentex) -> None: ) assert_matches_type(AgentTaskTracker, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_update(self, client: Agentex) -> None: response = client.tracker.with_raw_response.update( @@ -90,7 +90,7 @@ def test_raw_response_update(self, client: Agentex) -> None: tracker = response.parse() assert_matches_type(AgentTaskTracker, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_update(self, client: Agentex) -> None: with client.tracker.with_streaming_response.update( @@ -104,7 +104,7 @@ def test_streaming_response_update(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_path_params_update(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `tracker_id` but received ''"): @@ -112,13 +112,13 @@ def test_path_params_update(self, client: Agentex) -> None: tracker_id="", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_list(self, client: Agentex) -> None: tracker = client.tracker.list() assert_matches_type(TrackerListResponse, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_list_with_all_params(self, client: Agentex) -> None: tracker = client.tracker.list( @@ -127,7 +127,7 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: ) assert_matches_type(TrackerListResponse, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_list(self, client: Agentex) -> None: response = client.tracker.with_raw_response.list() @@ -137,7 +137,7 @@ def test_raw_response_list(self, client: Agentex) -> None: tracker = response.parse() assert_matches_type(TrackerListResponse, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_list(self, client: Agentex) -> None: with client.tracker.with_streaming_response.list() as response: @@ -155,7 +155,7 @@ class TestAsyncTracker: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: tracker = await async_client.tracker.retrieve( @@ -163,7 +163,7 @@ async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(AgentTaskTracker, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.tracker.with_raw_response.retrieve( @@ -175,7 +175,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: tracker = await response.parse() assert_matches_type(AgentTaskTracker, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.tracker.with_streaming_response.retrieve( @@ -189,7 +189,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `tracker_id` but received ''"): @@ -197,7 +197,7 @@ async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: "", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_update(self, async_client: AsyncAgentex) -> None: tracker = await async_client.tracker.update( @@ -205,7 +205,7 @@ async def test_method_update(self, async_client: AsyncAgentex) -> None: ) assert_matches_type(AgentTaskTracker, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_update_with_all_params(self, async_client: AsyncAgentex) -> None: tracker = await async_client.tracker.update( @@ -216,7 +216,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncAgentex) - ) assert_matches_type(AgentTaskTracker, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: response = await async_client.tracker.with_raw_response.update( @@ -228,7 +228,7 @@ async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: tracker = await response.parse() assert_matches_type(AgentTaskTracker, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_update(self, async_client: AsyncAgentex) -> None: async with async_client.tracker.with_streaming_response.update( @@ -242,7 +242,7 @@ async def test_streaming_response_update(self, async_client: AsyncAgentex) -> No assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_path_params_update(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `tracker_id` but received ''"): @@ -250,13 +250,13 @@ async def test_path_params_update(self, async_client: AsyncAgentex) -> None: tracker_id="", ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncAgentex) -> None: tracker = await async_client.tracker.list() assert_matches_type(TrackerListResponse, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: tracker = await async_client.tracker.list( @@ -265,7 +265,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> ) assert_matches_type(TrackerListResponse, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: response = await async_client.tracker.with_raw_response.list() @@ -275,7 +275,7 @@ async def test_raw_response_list(self, async_client: AsyncAgentex) -> None: tracker = await response.parse() assert_matches_type(TrackerListResponse, tracker, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None: async with async_client.tracker.with_streaming_response.list() as response: From 91d9a8bc78c678bff6b716953205c6d657b7b601 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 12 Aug 2025 20:25:19 +0000 Subject: [PATCH 0080/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index bb7b1e4b..fe718eb1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-11c219d0dae35b66569db21fd732cd50c3d164b742facbfd85272eb438698f60.yml -openapi_spec_hash: 83fa098892b79c51e8772ef87ac901da +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-a2699f769df3bcf51927c04b05dc6b26a73c54f8f46d46f90e9edf9e913fea08.yml +openapi_spec_hash: 7717b4250f1047ff3f30adae37dcdff6 config_hash: f6ec6016df1ff072b5b60cdf7b438361 From f5c7e7cf20d5f467c4479ffc291e983f8211398c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 13 Aug 2025 03:25:17 +0000 Subject: [PATCH 0081/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index fe718eb1..6758e4cf 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-a2699f769df3bcf51927c04b05dc6b26a73c54f8f46d46f90e9edf9e913fea08.yml -openapi_spec_hash: 7717b4250f1047ff3f30adae37dcdff6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b93c17faa52976d8e3be02251f4977f2c89a1c2bd89e913faffb3a7f6a53c231.yml +openapi_spec_hash: ea1ae484d9656349df4342a8f3db82f1 config_hash: f6ec6016df1ff072b5b60cdf7b438361 From 63c9a613e730cf0e1b7496ec31dfa487f17bbc78 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 13 Aug 2025 05:51:31 +0000 Subject: [PATCH 0082/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 69af4c2c..05994c50 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.2.8" + ".": "0.2.10" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 0b14a888..762f24fd 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.2.8" +version = "0.2.10" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index a0211692..dc8fbba7 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.2.8" # x-release-please-version +__version__ = "0.2.10" # x-release-please-version From 01e2334ac9bd7ffcd5aca965b01abbf72fc13085 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 14 Aug 2025 22:25:12 +0000 Subject: [PATCH 0083/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6758e4cf..9ce61676 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b93c17faa52976d8e3be02251f4977f2c89a1c2bd89e913faffb3a7f6a53c231.yml -openapi_spec_hash: ea1ae484d9656349df4342a8f3db82f1 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2d5d5f305f93d156fe32fab5f46ada4514aeba6215fea99115aa17b3b6d2f9c9.yml +openapi_spec_hash: 964a5178dec5d5f4accf4dbf743853e3 config_hash: f6ec6016df1ff072b5b60cdf7b438361 From 5b4c16f6902ccfdc5ddea372dc16fa16dd0eab3b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 14 Aug 2025 22:57:44 +0000 Subject: [PATCH 0084/1108] feat(api): api update --- .stats.yml | 4 +-- src/agentex/types/task_message_content.py | 36 ++++++++++++++++--- .../types/task_message_content_param.py | 34 +++++++++++++++--- 3 files changed, 64 insertions(+), 10 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9ce61676..153230de 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2d5d5f305f93d156fe32fab5f46ada4514aeba6215fea99115aa17b3b6d2f9c9.yml -openapi_spec_hash: 964a5178dec5d5f4accf4dbf743853e3 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-0f2236db4ff4adacf2e97ed9ad85269500786dbc4c6c83a2ac45b33fba43e259.yml +openapi_spec_hash: 43ad0cbb20696a241cdc83dd5f1366e2 config_hash: f6ec6016df1ff072b5b60cdf7b438361 diff --git a/src/agentex/types/task_message_content.py b/src/agentex/types/task_message_content.py index 126992b4..1d042525 100644 --- a/src/agentex/types/task_message_content.py +++ b/src/agentex/types/task_message_content.py @@ -1,16 +1,44 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Union -from typing_extensions import Annotated, TypeAlias +from typing import List, Union, Optional +from typing_extensions import Literal, Annotated, TypeAlias from .._utils import PropertyInfo +from .._models import BaseModel from .data_content import DataContent from .text_content import TextContent +from .message_style import MessageStyle +from .message_author import MessageAuthor from .tool_request_content import ToolRequestContent from .tool_response_content import ToolResponseContent -__all__ = ["TaskMessageContent"] +__all__ = ["TaskMessageContent", "ReasoningContent"] + + +class ReasoningContent(BaseModel): + author: MessageAuthor + """ + The role of the messages author, in this case `system`, `user`, `assistant`, or + `tool`. + """ + + summary: List[str] + """A list of short reasoning summaries""" + + content: Optional[List[str]] = None + """The reasoning content or chain-of-thought text""" + + style: Optional[MessageStyle] = None + """The style of the message. + + This is used by the client to determine how to display the message. + """ + + type: Optional[Literal["reasoning"]] = None + """The type of the message, in this case `reasoning`.""" + TaskMessageContent: TypeAlias = Annotated[ - Union[TextContent, DataContent, ToolRequestContent, ToolResponseContent], PropertyInfo(discriminator="type") + Union[TextContent, ReasoningContent, DataContent, ToolRequestContent, ToolResponseContent], + PropertyInfo(discriminator="type"), ] diff --git a/src/agentex/types/task_message_content_param.py b/src/agentex/types/task_message_content_param.py index 6991c64e..77c1c03e 100644 --- a/src/agentex/types/task_message_content_param.py +++ b/src/agentex/types/task_message_content_param.py @@ -2,16 +2,42 @@ from __future__ import annotations -from typing import Union -from typing_extensions import TypeAlias +from typing import List, Union, Optional +from typing_extensions import Literal, Required, TypeAlias, TypedDict +from .message_style import MessageStyle +from .message_author import MessageAuthor from .data_content_param import DataContentParam from .text_content_param import TextContentParam from .tool_request_content_param import ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam -__all__ = ["TaskMessageContentParam"] +__all__ = ["TaskMessageContentParam", "ReasoningContent"] + + +class ReasoningContent(TypedDict, total=False): + author: Required[MessageAuthor] + """ + The role of the messages author, in this case `system`, `user`, `assistant`, or + `tool`. + """ + + summary: Required[List[str]] + """A list of short reasoning summaries""" + + content: Optional[List[str]] + """The reasoning content or chain-of-thought text""" + + style: MessageStyle + """The style of the message. + + This is used by the client to determine how to display the message. + """ + + type: Literal["reasoning"] + """The type of the message, in this case `reasoning`.""" + TaskMessageContentParam: TypeAlias = Union[ - TextContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam + TextContentParam, ReasoningContent, DataContentParam, ToolRequestContentParam, ToolResponseContentParam ] From 68c5da4b89c6e4194bfa8a27abc3e2f801689f3c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 14 Aug 2025 22:59:08 +0000 Subject: [PATCH 0085/1108] feat(api): manual updates --- .stats.yml | 2 +- api.md | 1 + src/agentex/types/__init__.py | 2 ++ src/agentex/types/reasoning_content.py | 33 +++++++++++++++++ src/agentex/types/reasoning_content_param.py | 34 ++++++++++++++++++ src/agentex/types/task_message_content.py | 34 +++--------------- .../types/task_message_content_param.py | 35 +++---------------- 7 files changed, 80 insertions(+), 61 deletions(-) create mode 100644 src/agentex/types/reasoning_content.py create mode 100644 src/agentex/types/reasoning_content_param.py diff --git a/.stats.yml b/.stats.yml index 153230de..9614f3c1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-0f2236db4ff4adacf2e97ed9ad85269500786dbc4c6c83a2ac45b33fba43e259.yml openapi_spec_hash: 43ad0cbb20696a241cdc83dd5f1366e2 -config_hash: f6ec6016df1ff072b5b60cdf7b438361 +config_hash: c59262d25b94481ba4fe8f302e48e36d diff --git a/api.md b/api.md index 9c135dfa..e63cb04f 100644 --- a/api.md +++ b/api.md @@ -63,6 +63,7 @@ from agentex.types import ( DataContent, MessageAuthor, MessageStyle, + ReasoningContent, TaskMessage, TextContent, ToolRequestContent, diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index b502cb00..8ddda1c8 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -22,6 +22,7 @@ from .task_list_params import TaskListParams as TaskListParams from .agent_list_params import AgentListParams as AgentListParams from .event_list_params import EventListParams as EventListParams +from .reasoning_content import ReasoningContent as ReasoningContent from .state_list_params import StateListParams as StateListParams from .agent_rpc_response import AgentRpcResponse as AgentRpcResponse from .agent_task_tracker import AgentTaskTracker as AgentTaskTracker @@ -50,6 +51,7 @@ from .tool_response_content import ToolResponseContent as ToolResponseContent from .tracker_list_response import TrackerListResponse as TrackerListResponse from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams +from .reasoning_content_param import ReasoningContentParam as ReasoningContentParam from .agent_rpc_by_name_params import AgentRpcByNameParams as AgentRpcByNameParams from .task_message_content_param import TaskMessageContentParam as TaskMessageContentParam from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam diff --git a/src/agentex/types/reasoning_content.py b/src/agentex/types/reasoning_content.py new file mode 100644 index 00000000..98b35aef --- /dev/null +++ b/src/agentex/types/reasoning_content.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from typing_extensions import Literal + +from .._models import BaseModel +from .message_style import MessageStyle +from .message_author import MessageAuthor + +__all__ = ["ReasoningContent"] + + +class ReasoningContent(BaseModel): + author: MessageAuthor + """ + The role of the messages author, in this case `system`, `user`, `assistant`, or + `tool`. + """ + + summary: List[str] + """A list of short reasoning summaries""" + + content: Optional[List[str]] = None + """The reasoning content or chain-of-thought text""" + + style: Optional[MessageStyle] = None + """The style of the message. + + This is used by the client to determine how to display the message. + """ + + type: Optional[Literal["reasoning"]] = None + """The type of the message, in this case `reasoning`.""" diff --git a/src/agentex/types/reasoning_content_param.py b/src/agentex/types/reasoning_content_param.py new file mode 100644 index 00000000..f40a64c5 --- /dev/null +++ b/src/agentex/types/reasoning_content_param.py @@ -0,0 +1,34 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Optional +from typing_extensions import Literal, Required, TypedDict + +from .message_style import MessageStyle +from .message_author import MessageAuthor + +__all__ = ["ReasoningContentParam"] + + +class ReasoningContentParam(TypedDict, total=False): + author: Required[MessageAuthor] + """ + The role of the messages author, in this case `system`, `user`, `assistant`, or + `tool`. + """ + + summary: Required[List[str]] + """A list of short reasoning summaries""" + + content: Optional[List[str]] + """The reasoning content or chain-of-thought text""" + + style: MessageStyle + """The style of the message. + + This is used by the client to determine how to display the message. + """ + + type: Literal["reasoning"] + """The type of the message, in this case `reasoning`.""" diff --git a/src/agentex/types/task_message_content.py b/src/agentex/types/task_message_content.py index 1d042525..f180867b 100644 --- a/src/agentex/types/task_message_content.py +++ b/src/agentex/types/task_message_content.py @@ -1,42 +1,16 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import List, Union, Optional -from typing_extensions import Literal, Annotated, TypeAlias +from typing import Union +from typing_extensions import Annotated, TypeAlias from .._utils import PropertyInfo -from .._models import BaseModel from .data_content import DataContent from .text_content import TextContent -from .message_style import MessageStyle -from .message_author import MessageAuthor +from .reasoning_content import ReasoningContent from .tool_request_content import ToolRequestContent from .tool_response_content import ToolResponseContent -__all__ = ["TaskMessageContent", "ReasoningContent"] - - -class ReasoningContent(BaseModel): - author: MessageAuthor - """ - The role of the messages author, in this case `system`, `user`, `assistant`, or - `tool`. - """ - - summary: List[str] - """A list of short reasoning summaries""" - - content: Optional[List[str]] = None - """The reasoning content or chain-of-thought text""" - - style: Optional[MessageStyle] = None - """The style of the message. - - This is used by the client to determine how to display the message. - """ - - type: Optional[Literal["reasoning"]] = None - """The type of the message, in this case `reasoning`.""" - +__all__ = ["TaskMessageContent"] TaskMessageContent: TypeAlias = Annotated[ Union[TextContent, ReasoningContent, DataContent, ToolRequestContent, ToolResponseContent], diff --git a/src/agentex/types/task_message_content_param.py b/src/agentex/types/task_message_content_param.py index 77c1c03e..6349e4e7 100644 --- a/src/agentex/types/task_message_content_param.py +++ b/src/agentex/types/task_message_content_param.py @@ -2,42 +2,17 @@ from __future__ import annotations -from typing import List, Union, Optional -from typing_extensions import Literal, Required, TypeAlias, TypedDict +from typing import Union +from typing_extensions import TypeAlias -from .message_style import MessageStyle -from .message_author import MessageAuthor from .data_content_param import DataContentParam from .text_content_param import TextContentParam +from .reasoning_content_param import ReasoningContentParam from .tool_request_content_param import ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam -__all__ = ["TaskMessageContentParam", "ReasoningContent"] - - -class ReasoningContent(TypedDict, total=False): - author: Required[MessageAuthor] - """ - The role of the messages author, in this case `system`, `user`, `assistant`, or - `tool`. - """ - - summary: Required[List[str]] - """A list of short reasoning summaries""" - - content: Optional[List[str]] - """The reasoning content or chain-of-thought text""" - - style: MessageStyle - """The style of the message. - - This is used by the client to determine how to display the message. - """ - - type: Literal["reasoning"] - """The type of the message, in this case `reasoning`.""" - +__all__ = ["TaskMessageContentParam"] TaskMessageContentParam: TypeAlias = Union[ - TextContentParam, ReasoningContent, DataContentParam, ToolRequestContentParam, ToolResponseContentParam + TextContentParam, ReasoningContentParam, DataContentParam, ToolRequestContentParam, ToolResponseContentParam ] From b7a3b5aae57049a58cc98103c0b4b0c647e6606f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 14 Aug 2025 23:00:32 +0000 Subject: [PATCH 0086/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 05994c50..6b7b74c5 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.2.10" + ".": "0.3.0" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 762f24fd..af241f15 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.2.10" +version = "0.3.0" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index dc8fbba7..310ce27e 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.2.10" # x-release-please-version +__version__ = "0.3.0" # x-release-please-version From 452417dd2fe53e046985eac95d321f2da1adda28 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 15 Aug 2025 00:34:14 +0000 Subject: [PATCH 0087/1108] feat(api): manual updates --- .stats.yml | 4 ++-- src/agentex/types/task_message_delta.py | 27 +++++++++++++++++++++---- 2 files changed, 25 insertions(+), 6 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9614f3c1..069f10df 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-0f2236db4ff4adacf2e97ed9ad85269500786dbc4c6c83a2ac45b33fba43e259.yml -openapi_spec_hash: 43ad0cbb20696a241cdc83dd5f1366e2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-ce3ad40b5fdfb18aabf7cd1884de7792f1d653459e31a8e61a474ad66d9c5fc9.yml +openapi_spec_hash: 694d28f254e887f68fc1fd33440307f1 config_hash: c59262d25b94481ba4fe8f302e48e36d diff --git a/src/agentex/types/task_message_delta.py b/src/agentex/types/task_message_delta.py index 5a477e5a..b26ae753 100644 --- a/src/agentex/types/task_message_delta.py +++ b/src/agentex/types/task_message_delta.py @@ -1,16 +1,35 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Union -from typing_extensions import Annotated, TypeAlias +from typing import Union, Optional +from typing_extensions import Literal, Annotated, TypeAlias from .._utils import PropertyInfo +from .._models import BaseModel from .data_delta import DataDelta from .text_delta import TextDelta from .tool_request_delta import ToolRequestDelta from .tool_response_delta import ToolResponseDelta -__all__ = ["TaskMessageDelta"] +__all__ = ["TaskMessageDelta", "ReasoningSummaryDelta", "ReasoningContentDelta"] + + +class ReasoningSummaryDelta(BaseModel): + summary_index: int + + summary_delta: Optional[str] = None + + type: Optional[Literal["reasoning_summary"]] = None + + +class ReasoningContentDelta(BaseModel): + content_index: int + + content_delta: Optional[str] = None + + type: Optional[Literal["reasoning_content"]] = None + TaskMessageDelta: TypeAlias = Annotated[ - Union[TextDelta, DataDelta, ToolRequestDelta, ToolResponseDelta], PropertyInfo(discriminator="type") + Union[TextDelta, DataDelta, ToolRequestDelta, ToolResponseDelta, ReasoningSummaryDelta, ReasoningContentDelta], + PropertyInfo(discriminator="type"), ] From 2d99b9b790546ed99aa58920934cd4cb2b14f72d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 15 Aug 2025 00:35:36 +0000 Subject: [PATCH 0088/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 069f10df..f4725b1a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-ce3ad40b5fdfb18aabf7cd1884de7792f1d653459e31a8e61a474ad66d9c5fc9.yml -openapi_spec_hash: 694d28f254e887f68fc1fd33440307f1 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-29501785fbb6de9348a558389e9d0a9a94dddd50021f6f3ea8ff0fa95dddbeaf.yml +openapi_spec_hash: 523525acdac5482a17e6c99aa9382a50 config_hash: c59262d25b94481ba4fe8f302e48e36d From 72130f519c0def66007e552b8213d108b90ceed4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 15 Aug 2025 00:36:29 +0000 Subject: [PATCH 0089/1108] feat(api): manual updates --- .stats.yml | 2 +- api.md | 2 ++ src/agentex/types/__init__.py | 2 ++ src/agentex/types/reasoning_content_delta.py | 16 ++++++++++++ src/agentex/types/reasoning_summary_delta.py | 16 ++++++++++++ src/agentex/types/task_message_delta.py | 26 ++++---------------- 6 files changed, 42 insertions(+), 22 deletions(-) create mode 100644 src/agentex/types/reasoning_content_delta.py create mode 100644 src/agentex/types/reasoning_summary_delta.py diff --git a/.stats.yml b/.stats.yml index f4725b1a..93a8d335 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-29501785fbb6de9348a558389e9d0a9a94dddd50021f6f3ea8ff0fa95dddbeaf.yml openapi_spec_hash: 523525acdac5482a17e6c99aa9382a50 -config_hash: c59262d25b94481ba4fe8f302e48e36d +config_hash: c90254d21aa8a5ea34eb8d11a9dd05cb diff --git a/api.md b/api.md index e63cb04f..7f67632d 100644 --- a/api.md +++ b/api.md @@ -16,6 +16,8 @@ from agentex.types import ( AgentRpcResponse, AgentRpcResult, DataDelta, + ReasoningContentDelta, + ReasoningSummaryDelta, TaskMessageContent, TaskMessageDelta, TaskMessageUpdate, diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 8ddda1c8..62c11a73 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -51,7 +51,9 @@ from .tool_response_content import ToolResponseContent as ToolResponseContent from .tracker_list_response import TrackerListResponse as TrackerListResponse from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams +from .reasoning_content_delta import ReasoningContentDelta as ReasoningContentDelta from .reasoning_content_param import ReasoningContentParam as ReasoningContentParam +from .reasoning_summary_delta import ReasoningSummaryDelta as ReasoningSummaryDelta from .agent_rpc_by_name_params import AgentRpcByNameParams as AgentRpcByNameParams from .task_message_content_param import TaskMessageContentParam as TaskMessageContentParam from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam diff --git a/src/agentex/types/reasoning_content_delta.py b/src/agentex/types/reasoning_content_delta.py new file mode 100644 index 00000000..ae79ca8a --- /dev/null +++ b/src/agentex/types/reasoning_content_delta.py @@ -0,0 +1,16 @@ +# 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__ = ["ReasoningContentDelta"] + + +class ReasoningContentDelta(BaseModel): + content_index: int + + content_delta: Optional[str] = None + + type: Optional[Literal["reasoning_content"]] = None diff --git a/src/agentex/types/reasoning_summary_delta.py b/src/agentex/types/reasoning_summary_delta.py new file mode 100644 index 00000000..607cbec2 --- /dev/null +++ b/src/agentex/types/reasoning_summary_delta.py @@ -0,0 +1,16 @@ +# 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__ = ["ReasoningSummaryDelta"] + + +class ReasoningSummaryDelta(BaseModel): + summary_index: int + + summary_delta: Optional[str] = None + + type: Optional[Literal["reasoning_summary"]] = None diff --git a/src/agentex/types/task_message_delta.py b/src/agentex/types/task_message_delta.py index b26ae753..7fce76b7 100644 --- a/src/agentex/types/task_message_delta.py +++ b/src/agentex/types/task_message_delta.py @@ -1,33 +1,17 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Union, Optional -from typing_extensions import Literal, Annotated, TypeAlias +from typing import Union +from typing_extensions import Annotated, TypeAlias from .._utils import PropertyInfo -from .._models import BaseModel from .data_delta import DataDelta from .text_delta import TextDelta from .tool_request_delta import ToolRequestDelta from .tool_response_delta import ToolResponseDelta +from .reasoning_content_delta import ReasoningContentDelta +from .reasoning_summary_delta import ReasoningSummaryDelta -__all__ = ["TaskMessageDelta", "ReasoningSummaryDelta", "ReasoningContentDelta"] - - -class ReasoningSummaryDelta(BaseModel): - summary_index: int - - summary_delta: Optional[str] = None - - type: Optional[Literal["reasoning_summary"]] = None - - -class ReasoningContentDelta(BaseModel): - content_index: int - - content_delta: Optional[str] = None - - type: Optional[Literal["reasoning_content"]] = None - +__all__ = ["TaskMessageDelta"] TaskMessageDelta: TypeAlias = Annotated[ Union[TextDelta, DataDelta, ToolRequestDelta, ToolResponseDelta, ReasoningSummaryDelta, ReasoningContentDelta], From a493f213881d25e631b4014b7ef082b27c1a850a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 15 Aug 2025 00:37:29 +0000 Subject: [PATCH 0090/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 6b7b74c5..da59f99e 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.3.0" + ".": "0.4.0" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index af241f15..f7a7e145 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.3.0" +version = "0.4.0" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 310ce27e..cc4ed840 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.3.0" # x-release-please-version +__version__ = "0.4.0" # x-release-please-version From f2fe7da7e0562a8b0251aa1da419f1822bdfb986 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 16 Aug 2025 23:19:27 +0000 Subject: [PATCH 0091/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index da59f99e..3e2bf498 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.0" + ".": "0.4.1" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index f7a7e145..38990b84 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.0" +version = "0.4.1" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index cc4ed840..05b450fc 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.0" # x-release-please-version +__version__ = "0.4.1" # x-release-please-version From b46ccbaaf8099085a10adbecd7aff11ec1fdaee0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 17 Aug 2025 04:29:25 +0000 Subject: [PATCH 0092/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 3e2bf498..980ea052 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.1" + ".": "0.4.2" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 38990b84..874422ed 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.1" +version = "0.4.2" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 05b450fc..7e9fa607 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.1" # x-release-please-version +__version__ = "0.4.2" # x-release-please-version From fecc25db76fcb7d0006742ce6b6b834f376589b6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 17 Aug 2025 08:03:30 +0000 Subject: [PATCH 0093/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 980ea052..f8007191 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.2" + ".": "0.4.3" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 874422ed..f260d4bf 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.2" +version = "0.4.3" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 7e9fa607..c021f83b 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.2" # x-release-please-version +__version__ = "0.4.3" # x-release-please-version From 6b77ee63702fb6e9f0d12a2891592146da9a0791 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 17 Aug 2025 08:18:25 +0000 Subject: [PATCH 0094/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index f8007191..0c02950d 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.3" + ".": "0.4.4" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index f260d4bf..09246045 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.3" +version = "0.4.4" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index c021f83b..2814e289 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.3" # x-release-please-version +__version__ = "0.4.4" # x-release-please-version From 52e630ec4012c44986683c781f805e655be200f3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 18 Aug 2025 06:25:09 +0000 Subject: [PATCH 0095/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 93a8d335..88104714 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-29501785fbb6de9348a558389e9d0a9a94dddd50021f6f3ea8ff0fa95dddbeaf.yml -openapi_spec_hash: 523525acdac5482a17e6c99aa9382a50 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-3b2a2991693f29dd671a5cac6a764201d5e94758162dc366f4eee5fc8850f733.yml +openapi_spec_hash: 465c6a8b95a0e3c28d245f5386dded9c config_hash: c90254d21aa8a5ea34eb8d11a9dd05cb From 502a6157256312b7183436617e6c7b3422300b32 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 19 Aug 2025 15:25:15 +0000 Subject: [PATCH 0096/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 88104714..93a8d335 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-3b2a2991693f29dd671a5cac6a764201d5e94758162dc366f4eee5fc8850f733.yml -openapi_spec_hash: 465c6a8b95a0e3c28d245f5386dded9c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-29501785fbb6de9348a558389e9d0a9a94dddd50021f6f3ea8ff0fa95dddbeaf.yml +openapi_spec_hash: 523525acdac5482a17e6c99aa9382a50 config_hash: c90254d21aa8a5ea34eb8d11a9dd05cb From 01a181089a6c2f642d10ca85d75ef20c2d28eafe Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 19 Aug 2025 19:48:53 +0000 Subject: [PATCH 0097/1108] codegen metadata --- .stats.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.stats.yml b/.stats.yml index 93a8d335..9811afa5 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-29501785fbb6de9348a558389e9d0a9a94dddd50021f6f3ea8ff0fa95dddbeaf.yml openapi_spec_hash: 523525acdac5482a17e6c99aa9382a50 -config_hash: c90254d21aa8a5ea34eb8d11a9dd05cb +config_hash: 2de0ced4fd577245ea14e330212b2e50 From 7073d4be743d4a657fda18ab048b1d927843ab84 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 19 Aug 2025 19:49:52 +0000 Subject: [PATCH 0098/1108] feat(api): manual updates --- .stats.yml | 2 +- api.md | 1 + src/agentex/types/__init__.py | 1 + src/agentex/types/text_content.py | 3 ++- src/agentex/types/text_content_param.py | 3 ++- src/agentex/types/text_format.py | 7 +++++++ 6 files changed, 14 insertions(+), 3 deletions(-) create mode 100644 src/agentex/types/text_format.py diff --git a/.stats.yml b/.stats.yml index 9811afa5..48d7868e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-29501785fbb6de9348a558389e9d0a9a94dddd50021f6f3ea8ff0fa95dddbeaf.yml openapi_spec_hash: 523525acdac5482a17e6c99aa9382a50 -config_hash: 2de0ced4fd577245ea14e330212b2e50 +config_hash: aeabb3a919ad2763f5d0f41961a2520a diff --git a/api.md b/api.md index 7f67632d..4e3e6f83 100644 --- a/api.md +++ b/api.md @@ -68,6 +68,7 @@ from agentex.types import ( ReasoningContent, TaskMessage, TextContent, + TextFormat, ToolRequestContent, ToolResponseContent, MessageListResponse, diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 62c11a73..0445dfad 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -11,6 +11,7 @@ from .acp_type import AcpType as AcpType from .data_delta import DataDelta as DataDelta from .text_delta import TextDelta as TextDelta +from .text_format import TextFormat as TextFormat from .data_content import DataContent as DataContent from .task_message import TaskMessage as TaskMessage from .text_content import TextContent as TextContent diff --git a/src/agentex/types/text_content.py b/src/agentex/types/text_content.py index c96c797f..d664b7e7 100644 --- a/src/agentex/types/text_content.py +++ b/src/agentex/types/text_content.py @@ -4,6 +4,7 @@ from typing_extensions import Literal from .._models import BaseModel +from .text_format import TextFormat from .message_style import MessageStyle from .message_author import MessageAuthor @@ -37,7 +38,7 @@ class TextContent(BaseModel): attachments: Optional[List[Attachment]] = None """Optional list of file attachments with structured metadata.""" - format: Optional[Literal["markdown", "plain", "code"]] = None + format: Optional[TextFormat] = None """The format of the message. This is used by the client to determine how to display the message. diff --git a/src/agentex/types/text_content_param.py b/src/agentex/types/text_content_param.py index 87f357e0..9923a2a8 100644 --- a/src/agentex/types/text_content_param.py +++ b/src/agentex/types/text_content_param.py @@ -5,6 +5,7 @@ from typing import Iterable, Optional from typing_extensions import Literal, Required, TypedDict +from .text_format import TextFormat from .message_style import MessageStyle from .message_author import MessageAuthor @@ -38,7 +39,7 @@ class TextContentParam(TypedDict, total=False): attachments: Optional[Iterable[Attachment]] """Optional list of file attachments with structured metadata.""" - format: Literal["markdown", "plain", "code"] + format: TextFormat """The format of the message. This is used by the client to determine how to display the message. diff --git a/src/agentex/types/text_format.py b/src/agentex/types/text_format.py new file mode 100644 index 00000000..dea8ca30 --- /dev/null +++ b/src/agentex/types/text_format.py @@ -0,0 +1,7 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing_extensions import Literal, TypeAlias + +__all__ = ["TextFormat"] + +TextFormat: TypeAlias = Literal["markdown", "plain", "code"] From 2c1ad08221e66478c054f050aa667f952a8afc84 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 19 Aug 2025 23:25:38 +0000 Subject: [PATCH 0099/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 48d7868e..53739925 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-29501785fbb6de9348a558389e9d0a9a94dddd50021f6f3ea8ff0fa95dddbeaf.yml -openapi_spec_hash: 523525acdac5482a17e6c99aa9382a50 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80f1ace5353bc55b63c3065f7229699cacf3bdb3dc3ce4a5a479dd35c919c2bf.yml +openapi_spec_hash: 222d76b1af70ef4b692dee4dcf05e57c config_hash: aeabb3a919ad2763f5d0f41961a2520a From 87cbbf61a9926d790f6b083a14c6ac448bda4089 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 20 Aug 2025 19:25:14 +0000 Subject: [PATCH 0100/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 53739925..310d989e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80f1ace5353bc55b63c3065f7229699cacf3bdb3dc3ce4a5a479dd35c919c2bf.yml -openapi_spec_hash: 222d76b1af70ef4b692dee4dcf05e57c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b97510d27c568c48ae1618ab3509ea49c6036c5e6805e83507b221c2f3b5a09b.yml +openapi_spec_hash: f40aa1af94d6b5be6226c935e080c8cb config_hash: aeabb3a919ad2763f5d0f41961a2520a From 630ba455e1e1174eaef8ffe6623a610564927230 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 20 Aug 2025 20:25:19 +0000 Subject: [PATCH 0101/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 310d989e..53739925 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b97510d27c568c48ae1618ab3509ea49c6036c5e6805e83507b221c2f3b5a09b.yml -openapi_spec_hash: f40aa1af94d6b5be6226c935e080c8cb +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80f1ace5353bc55b63c3065f7229699cacf3bdb3dc3ce4a5a479dd35c919c2bf.yml +openapi_spec_hash: 222d76b1af70ef4b692dee4dcf05e57c config_hash: aeabb3a919ad2763f5d0f41961a2520a From 195803fdde2a5d768676edb8470219d8d9c84cde Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 20 Aug 2025 22:40:26 +0000 Subject: [PATCH 0102/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 0c02950d..e1eb2bdf 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.4" + ".": "0.4.5" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 09246045..e4198fb9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.4" +version = "0.4.5" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 2814e289..5f41f496 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.4" # x-release-please-version +__version__ = "0.4.5" # x-release-please-version From bd6ce2ed392ac161d9086c77fcdca45967032fcd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 20 Aug 2025 22:57:09 +0000 Subject: [PATCH 0103/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 53739925..a8022cc5 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80f1ace5353bc55b63c3065f7229699cacf3bdb3dc3ce4a5a479dd35c919c2bf.yml -openapi_spec_hash: 222d76b1af70ef4b692dee4dcf05e57c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b97510d27c568c48ae1618ab3509ea49c6036c5e6805e83507b221c2f3b5a09b.yml +openapi_spec_hash: db386e258e9548036a03ebf92ed5e95f config_hash: aeabb3a919ad2763f5d0f41961a2520a From c1be93a83cb55a4e4c6750c7fc958a05bdc916e9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 20 Aug 2025 23:06:30 +0000 Subject: [PATCH 0104/1108] feat(api): api update --- .stats.yml | 4 ++-- src/agentex/types/task.py | 4 +++- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/.stats.yml b/.stats.yml index a8022cc5..5070f01e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b97510d27c568c48ae1618ab3509ea49c6036c5e6805e83507b221c2f3b5a09b.yml -openapi_spec_hash: db386e258e9548036a03ebf92ed5e95f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4e747d1e081a07dcd47f7aaed0a8fc18c748658d4c8875f793daf4850e74b47c.yml +openapi_spec_hash: 3a159d7dc86cae47945e678009a197be config_hash: aeabb3a919ad2763f5d0f41961a2520a diff --git a/src/agentex/types/task.py b/src/agentex/types/task.py index c3afef3d..710ad445 100644 --- a/src/agentex/types/task.py +++ b/src/agentex/types/task.py @@ -1,6 +1,6 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Optional +from typing import Dict, Optional from datetime import datetime from typing_extensions import Literal @@ -16,6 +16,8 @@ class Task(BaseModel): name: Optional[str] = None + params: Optional[Dict[str, object]] = None + status: Optional[Literal["CANCELED", "COMPLETED", "FAILED", "RUNNING", "TERMINATED", "TIMED_OUT"]] = None status_reason: Optional[str] = None From 055c8330bbb244c8d5a6e48143720c488af42e4e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 20 Aug 2025 23:09:47 +0000 Subject: [PATCH 0105/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index e1eb2bdf..0c7cac16 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.5" + ".": "0.4.6" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index e4198fb9..dec7875a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.5" +version = "0.4.6" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 5f41f496..b122c81c 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.5" # x-release-please-version +__version__ = "0.4.6" # x-release-please-version From efe91b5d3051f6e2a7648a81507d084160d514ac Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 21 Aug 2025 19:30:01 +0000 Subject: [PATCH 0106/1108] chore: update github action --- .github/workflows/ci.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 02569035..a5495b1c 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -36,7 +36,7 @@ jobs: run: ./scripts/lint build: - if: github.repository == 'stainless-sdks/agentex-sdk-python' && (github.event_name == 'push' || github.event.pull_request.head.repo.fork) + if: github.event_name == 'push' || github.event.pull_request.head.repo.fork timeout-minutes: 10 name: build permissions: @@ -61,12 +61,14 @@ jobs: run: rye build - name: Get GitHub OIDC Token + if: github.repository == 'stainless-sdks/agentex-sdk-python' id: github-oidc uses: actions/github-script@v6 with: script: core.setOutput('github_token', await core.getIDToken()); - name: Upload tarball + if: github.repository == 'stainless-sdks/agentex-sdk-python' env: URL: https://pkg.stainless.com/s AUTH: ${{ steps.github-oidc.outputs.github_token }} From 8741a284b6f13526b559a46b43750bb9a70e62eb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 22 Aug 2025 04:52:12 +0000 Subject: [PATCH 0107/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 0c7cac16..c4437e1c 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.6" + ".": "0.4.7" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index dec7875a..59f9d1f1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.6" +version = "0.4.7" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index b122c81c..f214cb4d 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.6" # x-release-please-version +__version__ = "0.4.7" # x-release-please-version From 044a4c4b43d4806eb49592fc8303238ec471b002 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 22 Aug 2025 05:20:19 +0000 Subject: [PATCH 0108/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index c4437e1c..5f185fde 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.7" + ".": "0.4.8" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 59f9d1f1..ce8693f5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.7" +version = "0.4.8" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index f214cb4d..52d3cdc0 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.7" # x-release-please-version +__version__ = "0.4.8" # x-release-please-version From 4a421493085891028bb3a9ed0b401349e2183e24 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 22 Aug 2025 07:47:10 +0000 Subject: [PATCH 0109/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 5f185fde..c6de8623 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.8" + ".": "0.4.9" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index ce8693f5..dc6a223a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.8" +version = "0.4.9" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 52d3cdc0..918bb66e 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.8" # x-release-please-version +__version__ = "0.4.9" # x-release-please-version From a1cf6f849397bec52273ea2dba6ea21b4d520cac Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 24 Aug 2025 23:10:01 +0000 Subject: [PATCH 0110/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index c6de8623..1538b88f 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.9" + ".": "0.4.10" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index dc6a223a..c4670af9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.9" +version = "0.4.10" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 918bb66e..dedee372 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.9" # x-release-please-version +__version__ = "0.4.10" # x-release-please-version From 25527cc320fc1fb5472b781d3007cb802c51dca5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 25 Aug 2025 22:25:16 +0000 Subject: [PATCH 0111/1108] chore(internal): change ci workflow machines --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a5495b1c..f528a614 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -42,7 +42,7 @@ jobs: permissions: contents: read id-token: write - runs-on: depot-ubuntu-24.04 + runs-on: ${{ github.repository == 'stainless-sdks/agentex-sdk-python' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }} steps: - uses: actions/checkout@v4 From 9419a362226d112d8cd38c26a2170bf1d2c4b8e4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 26 Aug 2025 16:02:30 +0000 Subject: [PATCH 0112/1108] fix: avoid newer type syntax --- src/agentex/_models.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/agentex/_models.py b/src/agentex/_models.py index b8387ce9..92f7c10b 100644 --- a/src/agentex/_models.py +++ b/src/agentex/_models.py @@ -304,7 +304,7 @@ def model_dump( exclude_none=exclude_none, ) - return cast(dict[str, Any], json_safe(dumped)) if mode == "json" else dumped + return cast("dict[str, Any]", json_safe(dumped)) if mode == "json" else dumped @override def model_dump_json( From b8a06b000b37b2108812061c5d8a51a929f59b25 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 26 Aug 2025 21:53:51 +0000 Subject: [PATCH 0113/1108] chore(internal): update pyright exclude list --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index c4670af9..7a533e31 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -148,6 +148,7 @@ exclude = [ "_dev", ".venv", ".nox", + ".git", ] reportImplicitOverride = true From 252290e30680b6e6b49d34700467fd3ea977c601 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 26 Aug 2025 23:25:12 +0000 Subject: [PATCH 0114/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5070f01e..bd1fb205 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4e747d1e081a07dcd47f7aaed0a8fc18c748658d4c8875f793daf4850e74b47c.yml -openapi_spec_hash: 3a159d7dc86cae47945e678009a197be +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6eec9554350594d13aa61f6d3c384a54cbaba95481ee06c228a9d0a0aefaeda8.yml +openapi_spec_hash: 63770414d1be9807d9b7ebbef0ae9fee config_hash: aeabb3a919ad2763f5d0f41961a2520a From f130115593a8b2fbeb0e1d262ee9078835bb5204 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 29 Aug 2025 19:16:46 +0000 Subject: [PATCH 0115/1108] chore(internal): add Sequence related utils --- src/agentex/_types.py | 36 +++++++++++++++++++++++++++++++++- src/agentex/_utils/__init__.py | 1 + src/agentex/_utils/_typing.py | 5 +++++ tests/utils.py | 10 +++++++++- 4 files changed, 50 insertions(+), 2 deletions(-) diff --git a/src/agentex/_types.py b/src/agentex/_types.py index d01de4b1..002a10d8 100644 --- a/src/agentex/_types.py +++ b/src/agentex/_types.py @@ -13,10 +13,21 @@ Mapping, TypeVar, Callable, + Iterator, Optional, Sequence, ) -from typing_extensions import Set, Literal, Protocol, TypeAlias, TypedDict, override, runtime_checkable +from typing_extensions import ( + Set, + Literal, + Protocol, + TypeAlias, + TypedDict, + SupportsIndex, + overload, + override, + runtime_checkable, +) import httpx import pydantic @@ -217,3 +228,26 @@ class _GenericAlias(Protocol): class HttpxSendArgs(TypedDict, total=False): auth: httpx.Auth follow_redirects: bool + + +_T_co = TypeVar("_T_co", covariant=True) + + +if TYPE_CHECKING: + # This works because str.__contains__ does not accept object (either in typeshed or at runtime) + # https://github.com/hauntsaninja/useful_types/blob/5e9710f3875107d068e7679fd7fec9cfab0eff3b/useful_types/__init__.py#L285 + class SequenceNotStr(Protocol[_T_co]): + @overload + def __getitem__(self, index: SupportsIndex, /) -> _T_co: ... + @overload + def __getitem__(self, index: slice, /) -> Sequence[_T_co]: ... + def __contains__(self, value: object, /) -> bool: ... + def __len__(self) -> int: ... + def __iter__(self) -> Iterator[_T_co]: ... + def index(self, value: Any, start: int = 0, stop: int = ..., /) -> int: ... + def count(self, value: Any, /) -> int: ... + def __reversed__(self) -> Iterator[_T_co]: ... +else: + # just point this to a normal `Sequence` at runtime to avoid having to special case + # deserializing our custom sequence type + SequenceNotStr = Sequence diff --git a/src/agentex/_utils/__init__.py b/src/agentex/_utils/__init__.py index d4fda26f..ca547ce5 100644 --- a/src/agentex/_utils/__init__.py +++ b/src/agentex/_utils/__init__.py @@ -38,6 +38,7 @@ extract_type_arg as extract_type_arg, is_iterable_type as is_iterable_type, is_required_type as is_required_type, + is_sequence_type as is_sequence_type, is_annotated_type as is_annotated_type, is_type_alias_type as is_type_alias_type, strip_annotated_type as strip_annotated_type, diff --git a/src/agentex/_utils/_typing.py b/src/agentex/_utils/_typing.py index 1bac9542..845cd6b2 100644 --- a/src/agentex/_utils/_typing.py +++ b/src/agentex/_utils/_typing.py @@ -26,6 +26,11 @@ def is_list_type(typ: type) -> bool: return (get_origin(typ) or typ) == list +def is_sequence_type(typ: type) -> bool: + origin = get_origin(typ) or typ + return origin == typing_extensions.Sequence or origin == typing.Sequence or origin == _c_abc.Sequence + + def is_iterable_type(typ: type) -> bool: """If the given type is `typing.Iterable[T]`""" origin = get_origin(typ) or typ diff --git a/tests/utils.py b/tests/utils.py index f1d43e95..b1a74ded 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -4,7 +4,7 @@ import inspect import traceback import contextlib -from typing import Any, TypeVar, Iterator, cast +from typing import Any, TypeVar, Iterator, Sequence, cast from datetime import date, datetime from typing_extensions import Literal, get_args, get_origin, assert_type @@ -15,6 +15,7 @@ is_list_type, is_union_type, extract_type_arg, + is_sequence_type, is_annotated_type, is_type_alias_type, ) @@ -71,6 +72,13 @@ def assert_matches_type( if is_list_type(type_): return _assert_list_type(type_, value) + if is_sequence_type(type_): + assert isinstance(value, Sequence) + inner_type = get_args(type_)[0] + for entry in value: # type: ignore + assert_type(inner_type, entry) # type: ignore + return + if origin == str: assert isinstance(value, str) elif origin == int: From ad29e6ec44c17282d23c446a1ee45d1ab015cc1c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 2 Sep 2025 15:14:40 +0000 Subject: [PATCH 0116/1108] feat(types): replace List[str] with SequenceNotStr in params --- src/agentex/_utils/_transform.py | 6 ++++++ src/agentex/types/reasoning_content_param.py | 7 ++++--- 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/src/agentex/_utils/_transform.py b/src/agentex/_utils/_transform.py index b0cc20a7..f0bcefd4 100644 --- a/src/agentex/_utils/_transform.py +++ b/src/agentex/_utils/_transform.py @@ -16,6 +16,7 @@ lru_cache, is_mapping, is_iterable, + is_sequence, ) from .._files import is_base64_file_input from ._typing import ( @@ -24,6 +25,7 @@ extract_type_arg, is_iterable_type, is_required_type, + is_sequence_type, is_annotated_type, strip_annotated_type, ) @@ -184,6 +186,8 @@ def _transform_recursive( (is_list_type(stripped_type) and is_list(data)) # Iterable[T] or (is_iterable_type(stripped_type) and is_iterable(data) and not isinstance(data, str)) + # Sequence[T] + or (is_sequence_type(stripped_type) and is_sequence(data) and not isinstance(data, str)) ): # dicts are technically iterable, but it is an iterable on the keys of the dict and is not usually # intended as an iterable, so we don't transform it. @@ -346,6 +350,8 @@ async def _async_transform_recursive( (is_list_type(stripped_type) and is_list(data)) # Iterable[T] or (is_iterable_type(stripped_type) and is_iterable(data) and not isinstance(data, str)) + # Sequence[T] + or (is_sequence_type(stripped_type) and is_sequence(data) and not isinstance(data, str)) ): # dicts are technically iterable, but it is an iterable on the keys of the dict and is not usually # intended as an iterable, so we don't transform it. diff --git a/src/agentex/types/reasoning_content_param.py b/src/agentex/types/reasoning_content_param.py index f40a64c5..7fe923e4 100644 --- a/src/agentex/types/reasoning_content_param.py +++ b/src/agentex/types/reasoning_content_param.py @@ -2,9 +2,10 @@ from __future__ import annotations -from typing import List, Optional +from typing import Optional from typing_extensions import Literal, Required, TypedDict +from .._types import SequenceNotStr from .message_style import MessageStyle from .message_author import MessageAuthor @@ -18,10 +19,10 @@ class ReasoningContentParam(TypedDict, total=False): `tool`. """ - summary: Required[List[str]] + summary: Required[SequenceNotStr[str]] """A list of short reasoning summaries""" - content: Optional[List[str]] + content: Optional[SequenceNotStr[str]] """The reasoning content or chain-of-thought text""" style: MessageStyle From eb681391b281741c795f639a38ba8cd3727aa1f6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Sep 2025 21:54:58 +0000 Subject: [PATCH 0117/1108] feat: improve future compat with pydantic v3 --- src/agentex/_base_client.py | 6 +- src/agentex/_compat.py | 96 ++++++++--------- src/agentex/_models.py | 80 +++++++------- src/agentex/_utils/__init__.py | 10 +- src/agentex/_utils/_compat.py | 45 ++++++++ src/agentex/_utils/_datetime_parse.py | 136 ++++++++++++++++++++++++ src/agentex/_utils/_transform.py | 6 +- src/agentex/_utils/_typing.py | 2 +- src/agentex/_utils/_utils.py | 1 - tests/test_models.py | 48 ++++----- tests/test_transform.py | 16 +-- tests/test_utils/test_datetime_parse.py | 110 +++++++++++++++++++ tests/utils.py | 8 +- 13 files changed, 432 insertions(+), 132 deletions(-) create mode 100644 src/agentex/_utils/_compat.py create mode 100644 src/agentex/_utils/_datetime_parse.py create mode 100644 tests/test_utils/test_datetime_parse.py diff --git a/src/agentex/_base_client.py b/src/agentex/_base_client.py index 67eb675d..df53be60 100644 --- a/src/agentex/_base_client.py +++ b/src/agentex/_base_client.py @@ -59,7 +59,7 @@ ModelBuilderProtocol, ) from ._utils import is_dict, is_list, asyncify, is_given, lru_cache, is_mapping -from ._compat import PYDANTIC_V2, model_copy, model_dump +from ._compat import PYDANTIC_V1, model_copy, model_dump from ._models import GenericModel, FinalRequestOptions, validate_type, construct_type from ._response import ( APIResponse, @@ -232,7 +232,7 @@ def _set_private_attributes( model: Type[_T], options: FinalRequestOptions, ) -> None: - if PYDANTIC_V2 and getattr(self, "__pydantic_private__", None) is None: + if (not PYDANTIC_V1) and getattr(self, "__pydantic_private__", None) is None: self.__pydantic_private__ = {} self._model = model @@ -320,7 +320,7 @@ def _set_private_attributes( client: AsyncAPIClient, options: FinalRequestOptions, ) -> None: - if PYDANTIC_V2 and getattr(self, "__pydantic_private__", None) is None: + if (not PYDANTIC_V1) and getattr(self, "__pydantic_private__", None) is None: self.__pydantic_private__ = {} self._model = model diff --git a/src/agentex/_compat.py b/src/agentex/_compat.py index 92d9ee61..bdef67f0 100644 --- a/src/agentex/_compat.py +++ b/src/agentex/_compat.py @@ -12,14 +12,13 @@ _T = TypeVar("_T") _ModelT = TypeVar("_ModelT", bound=pydantic.BaseModel) -# --------------- Pydantic v2 compatibility --------------- +# --------------- Pydantic v2, v3 compatibility --------------- # Pyright incorrectly reports some of our functions as overriding a method when they don't # pyright: reportIncompatibleMethodOverride=false -PYDANTIC_V2 = pydantic.VERSION.startswith("2.") +PYDANTIC_V1 = pydantic.VERSION.startswith("1.") -# v1 re-exports if TYPE_CHECKING: def parse_date(value: date | StrBytesIntFloat) -> date: # noqa: ARG001 @@ -44,90 +43,92 @@ def is_typeddict(type_: type[Any]) -> bool: # noqa: ARG001 ... else: - if PYDANTIC_V2: - from pydantic.v1.typing import ( + # v1 re-exports + if PYDANTIC_V1: + from pydantic.typing import ( get_args as get_args, is_union as is_union, get_origin as get_origin, is_typeddict as is_typeddict, is_literal_type as is_literal_type, ) - from pydantic.v1.datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime + from pydantic.datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime else: - from pydantic.typing import ( + from ._utils import ( get_args as get_args, is_union as is_union, get_origin as get_origin, + parse_date as parse_date, is_typeddict as is_typeddict, + parse_datetime as parse_datetime, is_literal_type as is_literal_type, ) - from pydantic.datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime # refactored config if TYPE_CHECKING: from pydantic import ConfigDict as ConfigDict else: - if PYDANTIC_V2: - from pydantic import ConfigDict - else: + if PYDANTIC_V1: # TODO: provide an error message here? ConfigDict = None + else: + from pydantic import ConfigDict as ConfigDict # renamed methods / properties def parse_obj(model: type[_ModelT], value: object) -> _ModelT: - if PYDANTIC_V2: - return model.model_validate(value) - else: + if PYDANTIC_V1: return cast(_ModelT, model.parse_obj(value)) # pyright: ignore[reportDeprecated, reportUnnecessaryCast] + else: + return model.model_validate(value) def field_is_required(field: FieldInfo) -> bool: - if PYDANTIC_V2: - return field.is_required() - return field.required # type: ignore + if PYDANTIC_V1: + return field.required # type: ignore + return field.is_required() def field_get_default(field: FieldInfo) -> Any: value = field.get_default() - if PYDANTIC_V2: - from pydantic_core import PydanticUndefined - - if value == PydanticUndefined: - return None + if PYDANTIC_V1: return value + from pydantic_core import PydanticUndefined + + if value == PydanticUndefined: + return None return value def field_outer_type(field: FieldInfo) -> Any: - if PYDANTIC_V2: - return field.annotation - return field.outer_type_ # type: ignore + if PYDANTIC_V1: + return field.outer_type_ # type: ignore + return field.annotation def get_model_config(model: type[pydantic.BaseModel]) -> Any: - if PYDANTIC_V2: - return model.model_config - return model.__config__ # type: ignore + if PYDANTIC_V1: + return model.__config__ # type: ignore + return model.model_config def get_model_fields(model: type[pydantic.BaseModel]) -> dict[str, FieldInfo]: - if PYDANTIC_V2: - return model.model_fields - return model.__fields__ # type: ignore + if PYDANTIC_V1: + return model.__fields__ # type: ignore + return model.model_fields def model_copy(model: _ModelT, *, deep: bool = False) -> _ModelT: - if PYDANTIC_V2: - return model.model_copy(deep=deep) - return model.copy(deep=deep) # type: ignore + if PYDANTIC_V1: + return model.copy(deep=deep) # type: ignore + return model.model_copy(deep=deep) def model_json(model: pydantic.BaseModel, *, indent: int | None = None) -> str: - if PYDANTIC_V2: - return model.model_dump_json(indent=indent) - return model.json(indent=indent) # type: ignore + if PYDANTIC_V1: + return model.json(indent=indent) # type: ignore + return model.model_dump_json(indent=indent) def model_dump( @@ -139,14 +140,14 @@ def model_dump( warnings: bool = True, mode: Literal["json", "python"] = "python", ) -> dict[str, Any]: - if PYDANTIC_V2 or hasattr(model, "model_dump"): + if (not PYDANTIC_V1) or hasattr(model, "model_dump"): return model.model_dump( mode=mode, exclude=exclude, exclude_unset=exclude_unset, exclude_defaults=exclude_defaults, # warnings are not supported in Pydantic v1 - warnings=warnings if PYDANTIC_V2 else True, + warnings=True if PYDANTIC_V1 else warnings, ) return cast( "dict[str, Any]", @@ -159,9 +160,9 @@ def model_dump( def model_parse(model: type[_ModelT], data: Any) -> _ModelT: - if PYDANTIC_V2: - return model.model_validate(data) - return model.parse_obj(data) # pyright: ignore[reportDeprecated] + if PYDANTIC_V1: + return model.parse_obj(data) # pyright: ignore[reportDeprecated] + return model.model_validate(data) # generic models @@ -170,17 +171,16 @@ def model_parse(model: type[_ModelT], data: Any) -> _ModelT: class GenericModel(pydantic.BaseModel): ... else: - if PYDANTIC_V2: + if PYDANTIC_V1: + import pydantic.generics + + class GenericModel(pydantic.generics.GenericModel, pydantic.BaseModel): ... + else: # there no longer needs to be a distinction in v2 but # we still have to create our own subclass to avoid # inconsistent MRO ordering errors class GenericModel(pydantic.BaseModel): ... - else: - import pydantic.generics - - class GenericModel(pydantic.generics.GenericModel, pydantic.BaseModel): ... - # cached properties if TYPE_CHECKING: diff --git a/src/agentex/_models.py b/src/agentex/_models.py index 92f7c10b..3a6017ef 100644 --- a/src/agentex/_models.py +++ b/src/agentex/_models.py @@ -50,7 +50,7 @@ strip_annotated_type, ) from ._compat import ( - PYDANTIC_V2, + PYDANTIC_V1, ConfigDict, GenericModel as BaseGenericModel, get_args, @@ -81,11 +81,7 @@ class _ConfigProtocol(Protocol): class BaseModel(pydantic.BaseModel): - if PYDANTIC_V2: - model_config: ClassVar[ConfigDict] = ConfigDict( - extra="allow", defer_build=coerce_boolean(os.environ.get("DEFER_PYDANTIC_BUILD", "true")) - ) - else: + if PYDANTIC_V1: @property @override @@ -95,6 +91,10 @@ def model_fields_set(self) -> set[str]: class Config(pydantic.BaseConfig): # pyright: ignore[reportDeprecated] extra: Any = pydantic.Extra.allow # type: ignore + else: + model_config: ClassVar[ConfigDict] = ConfigDict( + extra="allow", defer_build=coerce_boolean(os.environ.get("DEFER_PYDANTIC_BUILD", "true")) + ) def to_dict( self, @@ -215,25 +215,25 @@ def construct( # pyright: ignore[reportIncompatibleMethodOverride] if key not in model_fields: parsed = construct_type(value=value, type_=extra_field_type) if extra_field_type is not None else value - if PYDANTIC_V2: - _extra[key] = parsed - else: + if PYDANTIC_V1: _fields_set.add(key) fields_values[key] = parsed + else: + _extra[key] = parsed object.__setattr__(m, "__dict__", fields_values) - if PYDANTIC_V2: - # these properties are copied from Pydantic's `model_construct()` method - object.__setattr__(m, "__pydantic_private__", None) - object.__setattr__(m, "__pydantic_extra__", _extra) - object.__setattr__(m, "__pydantic_fields_set__", _fields_set) - else: + if PYDANTIC_V1: # init_private_attributes() does not exist in v2 m._init_private_attributes() # type: ignore # copied from Pydantic v1's `construct()` method object.__setattr__(m, "__fields_set__", _fields_set) + else: + # these properties are copied from Pydantic's `model_construct()` method + object.__setattr__(m, "__pydantic_private__", None) + object.__setattr__(m, "__pydantic_extra__", _extra) + object.__setattr__(m, "__pydantic_fields_set__", _fields_set) return m @@ -243,7 +243,7 @@ def construct( # pyright: ignore[reportIncompatibleMethodOverride] # although not in practice model_construct = construct - if not PYDANTIC_V2: + if PYDANTIC_V1: # we define aliases for some of the new pydantic v2 methods so # that we can just document these methods without having to specify # a specific pydantic version as some users may not know which @@ -363,10 +363,10 @@ def _construct_field(value: object, field: FieldInfo, key: str) -> object: if value is None: return field_get_default(field) - if PYDANTIC_V2: - type_ = field.annotation - else: + if PYDANTIC_V1: type_ = cast(type, field.outer_type_) # type: ignore + else: + type_ = field.annotation # type: ignore if type_ is None: raise RuntimeError(f"Unexpected field type is None for {key}") @@ -375,7 +375,7 @@ def _construct_field(value: object, field: FieldInfo, key: str) -> object: def _get_extra_fields_type(cls: type[pydantic.BaseModel]) -> type | None: - if not PYDANTIC_V2: + if PYDANTIC_V1: # TODO return None @@ -628,30 +628,30 @@ def _build_discriminated_union_meta(*, union: type, meta_annotations: tuple[Any, for variant in get_args(union): variant = strip_annotated_type(variant) if is_basemodel_type(variant): - if PYDANTIC_V2: - field = _extract_field_schema_pv2(variant, discriminator_field_name) - if not field: + if PYDANTIC_V1: + field_info = cast("dict[str, FieldInfo]", variant.__fields__).get(discriminator_field_name) # pyright: ignore[reportDeprecated, reportUnnecessaryCast] + if not field_info: continue # Note: if one variant defines an alias then they all should - discriminator_alias = field.get("serialization_alias") - - field_schema = field["schema"] + discriminator_alias = field_info.alias - if field_schema["type"] == "literal": - for entry in cast("LiteralSchema", field_schema)["expected"]: + if (annotation := getattr(field_info, "annotation", None)) and is_literal_type(annotation): + for entry in get_args(annotation): if isinstance(entry, str): mapping[entry] = variant else: - field_info = cast("dict[str, FieldInfo]", variant.__fields__).get(discriminator_field_name) # pyright: ignore[reportDeprecated, reportUnnecessaryCast] - if not field_info: + field = _extract_field_schema_pv2(variant, discriminator_field_name) + if not field: continue # Note: if one variant defines an alias then they all should - discriminator_alias = field_info.alias + discriminator_alias = field.get("serialization_alias") - if (annotation := getattr(field_info, "annotation", None)) and is_literal_type(annotation): - for entry in get_args(annotation): + field_schema = field["schema"] + + if field_schema["type"] == "literal": + for entry in cast("LiteralSchema", field_schema)["expected"]: if isinstance(entry, str): mapping[entry] = variant @@ -714,7 +714,7 @@ class GenericModel(BaseGenericModel, BaseModel): pass -if PYDANTIC_V2: +if not PYDANTIC_V1: from pydantic import TypeAdapter as _TypeAdapter _CachedTypeAdapter = cast("TypeAdapter[object]", lru_cache(maxsize=None)(_TypeAdapter)) @@ -782,12 +782,12 @@ class FinalRequestOptions(pydantic.BaseModel): json_data: Union[Body, None] = None extra_json: Union[AnyMapping, None] = None - if PYDANTIC_V2: - model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True) - else: + if PYDANTIC_V1: class Config(pydantic.BaseConfig): # pyright: ignore[reportDeprecated] arbitrary_types_allowed: bool = True + else: + model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True) def get_max_retries(self, max_retries: int) -> int: if isinstance(self.max_retries, NotGiven): @@ -820,9 +820,9 @@ def construct( # type: ignore key: strip_not_given(value) for key, value in values.items() } - if PYDANTIC_V2: - return super().model_construct(_fields_set, **kwargs) - return cast(FinalRequestOptions, super().construct(_fields_set, **kwargs)) # pyright: ignore[reportDeprecated] + if PYDANTIC_V1: + return cast(FinalRequestOptions, super().construct(_fields_set, **kwargs)) # pyright: ignore[reportDeprecated] + return super().model_construct(_fields_set, **kwargs) if not TYPE_CHECKING: # type checkers incorrectly complain about this assignment diff --git a/src/agentex/_utils/__init__.py b/src/agentex/_utils/__init__.py index ca547ce5..dc64e29a 100644 --- a/src/agentex/_utils/__init__.py +++ b/src/agentex/_utils/__init__.py @@ -10,7 +10,6 @@ lru_cache as lru_cache, is_mapping as is_mapping, is_tuple_t as is_tuple_t, - parse_date as parse_date, is_iterable as is_iterable, is_sequence as is_sequence, coerce_float as coerce_float, @@ -23,7 +22,6 @@ coerce_boolean as coerce_boolean, coerce_integer as coerce_integer, file_from_path as file_from_path, - parse_datetime as parse_datetime, strip_not_given as strip_not_given, deepcopy_minimal as deepcopy_minimal, get_async_library as get_async_library, @@ -32,6 +30,13 @@ maybe_coerce_boolean as maybe_coerce_boolean, maybe_coerce_integer as maybe_coerce_integer, ) +from ._compat import ( + get_args as get_args, + is_union as is_union, + get_origin as get_origin, + is_typeddict as is_typeddict, + is_literal_type as is_literal_type, +) from ._typing import ( is_list_type as is_list_type, is_union_type as is_union_type, @@ -56,3 +61,4 @@ function_has_argument as function_has_argument, assert_signatures_in_sync as assert_signatures_in_sync, ) +from ._datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime diff --git a/src/agentex/_utils/_compat.py b/src/agentex/_utils/_compat.py new file mode 100644 index 00000000..dd703233 --- /dev/null +++ b/src/agentex/_utils/_compat.py @@ -0,0 +1,45 @@ +from __future__ import annotations + +import sys +import typing_extensions +from typing import Any, Type, Union, Literal, Optional +from datetime import date, datetime +from typing_extensions import get_args as _get_args, get_origin as _get_origin + +from .._types import StrBytesIntFloat +from ._datetime_parse import parse_date as _parse_date, parse_datetime as _parse_datetime + +_LITERAL_TYPES = {Literal, typing_extensions.Literal} + + +def get_args(tp: type[Any]) -> tuple[Any, ...]: + return _get_args(tp) + + +def get_origin(tp: type[Any]) -> type[Any] | None: + return _get_origin(tp) + + +def is_union(tp: Optional[Type[Any]]) -> bool: + if sys.version_info < (3, 10): + return tp is Union # type: ignore[comparison-overlap] + else: + import types + + return tp is Union or tp is types.UnionType + + +def is_typeddict(tp: Type[Any]) -> bool: + return typing_extensions.is_typeddict(tp) + + +def is_literal_type(tp: Type[Any]) -> bool: + return get_origin(tp) in _LITERAL_TYPES + + +def parse_date(value: Union[date, StrBytesIntFloat]) -> date: + return _parse_date(value) + + +def parse_datetime(value: Union[datetime, StrBytesIntFloat]) -> datetime: + return _parse_datetime(value) diff --git a/src/agentex/_utils/_datetime_parse.py b/src/agentex/_utils/_datetime_parse.py new file mode 100644 index 00000000..7cb9d9e6 --- /dev/null +++ b/src/agentex/_utils/_datetime_parse.py @@ -0,0 +1,136 @@ +""" +This file contains code from https://github.com/pydantic/pydantic/blob/main/pydantic/v1/datetime_parse.py +without the Pydantic v1 specific errors. +""" + +from __future__ import annotations + +import re +from typing import Dict, Union, Optional +from datetime import date, datetime, timezone, timedelta + +from .._types import StrBytesIntFloat + +date_expr = r"(?P\d{4})-(?P\d{1,2})-(?P\d{1,2})" +time_expr = ( + r"(?P\d{1,2}):(?P\d{1,2})" + r"(?::(?P\d{1,2})(?:\.(?P\d{1,6})\d{0,6})?)?" + r"(?PZ|[+-]\d{2}(?::?\d{2})?)?$" +) + +date_re = re.compile(f"{date_expr}$") +datetime_re = re.compile(f"{date_expr}[T ]{time_expr}") + + +EPOCH = datetime(1970, 1, 1) +# if greater than this, the number is in ms, if less than or equal it's in seconds +# (in seconds this is 11th October 2603, in ms it's 20th August 1970) +MS_WATERSHED = int(2e10) +# slightly more than datetime.max in ns - (datetime.max - EPOCH).total_seconds() * 1e9 +MAX_NUMBER = int(3e20) + + +def _get_numeric(value: StrBytesIntFloat, native_expected_type: str) -> Union[None, int, float]: + if isinstance(value, (int, float)): + return value + try: + return float(value) + except ValueError: + return None + except TypeError: + raise TypeError(f"invalid type; expected {native_expected_type}, string, bytes, int or float") from None + + +def _from_unix_seconds(seconds: Union[int, float]) -> datetime: + if seconds > MAX_NUMBER: + return datetime.max + elif seconds < -MAX_NUMBER: + return datetime.min + + while abs(seconds) > MS_WATERSHED: + seconds /= 1000 + dt = EPOCH + timedelta(seconds=seconds) + return dt.replace(tzinfo=timezone.utc) + + +def _parse_timezone(value: Optional[str]) -> Union[None, int, timezone]: + if value == "Z": + return timezone.utc + elif value is not None: + offset_mins = int(value[-2:]) if len(value) > 3 else 0 + offset = 60 * int(value[1:3]) + offset_mins + if value[0] == "-": + offset = -offset + return timezone(timedelta(minutes=offset)) + else: + return None + + +def parse_datetime(value: Union[datetime, StrBytesIntFloat]) -> datetime: + """ + Parse a datetime/int/float/string and return a datetime.datetime. + + This function supports time zone offsets. When the input contains one, + the output uses a timezone with a fixed offset from UTC. + + Raise ValueError if the input is well formatted but not a valid datetime. + Raise ValueError if the input isn't well formatted. + """ + if isinstance(value, datetime): + return value + + number = _get_numeric(value, "datetime") + if number is not None: + return _from_unix_seconds(number) + + if isinstance(value, bytes): + value = value.decode() + + assert not isinstance(value, (float, int)) + + match = datetime_re.match(value) + if match is None: + raise ValueError("invalid datetime format") + + kw = match.groupdict() + if kw["microsecond"]: + kw["microsecond"] = kw["microsecond"].ljust(6, "0") + + tzinfo = _parse_timezone(kw.pop("tzinfo")) + kw_: Dict[str, Union[None, int, timezone]] = {k: int(v) for k, v in kw.items() if v is not None} + kw_["tzinfo"] = tzinfo + + return datetime(**kw_) # type: ignore + + +def parse_date(value: Union[date, StrBytesIntFloat]) -> date: + """ + Parse a date/int/float/string and return a datetime.date. + + Raise ValueError if the input is well formatted but not a valid date. + Raise ValueError if the input isn't well formatted. + """ + if isinstance(value, date): + if isinstance(value, datetime): + return value.date() + else: + return value + + number = _get_numeric(value, "date") + if number is not None: + return _from_unix_seconds(number).date() + + if isinstance(value, bytes): + value = value.decode() + + assert not isinstance(value, (float, int)) + match = date_re.match(value) + if match is None: + raise ValueError("invalid date format") + + kw = {k: int(v) for k, v in match.groupdict().items()} + + try: + return date(**kw) + except ValueError: + raise ValueError("invalid date format") from None diff --git a/src/agentex/_utils/_transform.py b/src/agentex/_utils/_transform.py index f0bcefd4..c19124f0 100644 --- a/src/agentex/_utils/_transform.py +++ b/src/agentex/_utils/_transform.py @@ -19,6 +19,7 @@ is_sequence, ) from .._files import is_base64_file_input +from ._compat import get_origin, is_typeddict from ._typing import ( is_list_type, is_union_type, @@ -29,7 +30,6 @@ is_annotated_type, strip_annotated_type, ) -from .._compat import get_origin, model_dump, is_typeddict _T = TypeVar("_T") @@ -169,6 +169,8 @@ def _transform_recursive( Defaults to the same value as the `annotation` argument. """ + from .._compat import model_dump + if inner_type is None: inner_type = annotation @@ -333,6 +335,8 @@ async def _async_transform_recursive( Defaults to the same value as the `annotation` argument. """ + from .._compat import model_dump + if inner_type is None: inner_type = annotation diff --git a/src/agentex/_utils/_typing.py b/src/agentex/_utils/_typing.py index 845cd6b2..193109f3 100644 --- a/src/agentex/_utils/_typing.py +++ b/src/agentex/_utils/_typing.py @@ -15,7 +15,7 @@ from ._utils import lru_cache from .._types import InheritsGeneric -from .._compat import is_union as _is_union +from ._compat import is_union as _is_union def is_annotated_type(typ: type) -> bool: diff --git a/src/agentex/_utils/_utils.py b/src/agentex/_utils/_utils.py index ea3cf3f2..f0818595 100644 --- a/src/agentex/_utils/_utils.py +++ b/src/agentex/_utils/_utils.py @@ -22,7 +22,6 @@ import sniffio from .._types import NotGiven, FileTypes, NotGivenOr, HeadersLike -from .._compat import parse_date as parse_date, parse_datetime as parse_datetime _T = TypeVar("_T") _TupleT = TypeVar("_TupleT", bound=Tuple[object, ...]) diff --git a/tests/test_models.py b/tests/test_models.py index 14d98180..d2f03273 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -8,7 +8,7 @@ from pydantic import Field from agentex._utils import PropertyInfo -from agentex._compat import PYDANTIC_V2, parse_obj, model_dump, model_json +from agentex._compat import PYDANTIC_V1, parse_obj, model_dump, model_json from agentex._models import BaseModel, construct_type @@ -294,12 +294,12 @@ class Model(BaseModel): assert cast(bool, m.foo) is True m = Model.construct(foo={"name": 3}) - if PYDANTIC_V2: - assert isinstance(m.foo, Submodel1) - assert m.foo.name == 3 # type: ignore - else: + if PYDANTIC_V1: assert isinstance(m.foo, Submodel2) assert m.foo.name == "3" + else: + assert isinstance(m.foo, Submodel1) + assert m.foo.name == 3 # type: ignore def test_list_of_unions() -> None: @@ -426,10 +426,10 @@ class Model(BaseModel): expected = datetime(2019, 12, 27, 18, 11, 19, 117000, tzinfo=timezone.utc) - if PYDANTIC_V2: - expected_json = '{"created_at":"2019-12-27T18:11:19.117000Z"}' - else: + if PYDANTIC_V1: expected_json = '{"created_at": "2019-12-27T18:11:19.117000+00:00"}' + else: + expected_json = '{"created_at":"2019-12-27T18:11:19.117000Z"}' model = Model.construct(created_at="2019-12-27T18:11:19.117Z") assert model.created_at == expected @@ -531,7 +531,7 @@ class Model2(BaseModel): assert m4.to_dict(mode="python") == {"created_at": datetime.fromisoformat(time_str)} assert m4.to_dict(mode="json") == {"created_at": time_str} - if not PYDANTIC_V2: + if PYDANTIC_V1: with pytest.raises(ValueError, match="warnings is only supported in Pydantic v2"): m.to_dict(warnings=False) @@ -556,7 +556,7 @@ class Model(BaseModel): assert m3.model_dump() == {"foo": None} assert m3.model_dump(exclude_none=True) == {} - if not PYDANTIC_V2: + if PYDANTIC_V1: with pytest.raises(ValueError, match="round_trip is only supported in Pydantic v2"): m.model_dump(round_trip=True) @@ -580,10 +580,10 @@ class Model(BaseModel): assert json.loads(m.to_json()) == {"FOO": "hello"} assert json.loads(m.to_json(use_api_names=False)) == {"foo": "hello"} - if PYDANTIC_V2: - assert m.to_json(indent=None) == '{"FOO":"hello"}' - else: + if PYDANTIC_V1: assert m.to_json(indent=None) == '{"FOO": "hello"}' + else: + assert m.to_json(indent=None) == '{"FOO":"hello"}' m2 = Model() assert json.loads(m2.to_json()) == {} @@ -595,7 +595,7 @@ class Model(BaseModel): assert json.loads(m3.to_json()) == {"FOO": None} assert json.loads(m3.to_json(exclude_none=True)) == {} - if not PYDANTIC_V2: + if PYDANTIC_V1: with pytest.raises(ValueError, match="warnings is only supported in Pydantic v2"): m.to_json(warnings=False) @@ -622,7 +622,7 @@ class Model(BaseModel): assert json.loads(m3.model_dump_json()) == {"foo": None} assert json.loads(m3.model_dump_json(exclude_none=True)) == {} - if not PYDANTIC_V2: + if PYDANTIC_V1: with pytest.raises(ValueError, match="round_trip is only supported in Pydantic v2"): m.model_dump_json(round_trip=True) @@ -679,12 +679,12 @@ class B(BaseModel): ) assert isinstance(m, A) assert m.type == "a" - if PYDANTIC_V2: - assert m.data == 100 # type: ignore[comparison-overlap] - else: + if PYDANTIC_V1: # pydantic v1 automatically converts inputs to strings # if the expected type is a str assert m.data == "100" + else: + assert m.data == 100 # type: ignore[comparison-overlap] def test_discriminated_unions_unknown_variant() -> None: @@ -768,12 +768,12 @@ class B(BaseModel): ) assert isinstance(m, A) assert m.foo_type == "a" - if PYDANTIC_V2: - assert m.data == 100 # type: ignore[comparison-overlap] - else: + if PYDANTIC_V1: # pydantic v1 automatically converts inputs to strings # if the expected type is a str assert m.data == "100" + else: + assert m.data == 100 # type: ignore[comparison-overlap] def test_discriminated_unions_overlapping_discriminators_invalid_data() -> None: @@ -833,7 +833,7 @@ class B(BaseModel): assert UnionType.__discriminator__ is discriminator -@pytest.mark.skipif(not PYDANTIC_V2, reason="TypeAliasType is not supported in Pydantic v1") +@pytest.mark.skipif(PYDANTIC_V1, reason="TypeAliasType is not supported in Pydantic v1") def test_type_alias_type() -> None: Alias = TypeAliasType("Alias", str) # pyright: ignore @@ -849,7 +849,7 @@ class Model(BaseModel): assert m.union == "bar" -@pytest.mark.skipif(not PYDANTIC_V2, reason="TypeAliasType is not supported in Pydantic v1") +@pytest.mark.skipif(PYDANTIC_V1, reason="TypeAliasType is not supported in Pydantic v1") def test_field_named_cls() -> None: class Model(BaseModel): cls: str @@ -936,7 +936,7 @@ class Type2(BaseModel): assert isinstance(model.value, InnerType2) -@pytest.mark.skipif(not PYDANTIC_V2, reason="this is only supported in pydantic v2 for now") +@pytest.mark.skipif(PYDANTIC_V1, reason="this is only supported in pydantic v2 for now") def test_extra_properties() -> None: class Item(BaseModel): prop: int diff --git a/tests/test_transform.py b/tests/test_transform.py index 606a1788..20ef1c66 100644 --- a/tests/test_transform.py +++ b/tests/test_transform.py @@ -15,7 +15,7 @@ parse_datetime, async_transform as _async_transform, ) -from agentex._compat import PYDANTIC_V2 +from agentex._compat import PYDANTIC_V1 from agentex._models import BaseModel _T = TypeVar("_T") @@ -189,7 +189,7 @@ class DateModel(BaseModel): @pytest.mark.asyncio async def test_iso8601_format(use_async: bool) -> None: dt = datetime.fromisoformat("2023-02-23T14:16:36.337692+00:00") - tz = "Z" if PYDANTIC_V2 else "+00:00" + tz = "+00:00" if PYDANTIC_V1 else "Z" assert await transform({"foo": dt}, DatetimeDict, use_async) == {"foo": "2023-02-23T14:16:36.337692+00:00"} # type: ignore[comparison-overlap] assert await transform(DatetimeModel(foo=dt), Any, use_async) == {"foo": "2023-02-23T14:16:36.337692" + tz} # type: ignore[comparison-overlap] @@ -297,11 +297,11 @@ async def test_pydantic_unknown_field(use_async: bool) -> None: @pytest.mark.asyncio async def test_pydantic_mismatched_types(use_async: bool) -> None: model = MyModel.construct(foo=True) - if PYDANTIC_V2: + if PYDANTIC_V1: + params = await transform(model, Any, use_async) + else: with pytest.warns(UserWarning): params = await transform(model, Any, use_async) - else: - params = await transform(model, Any, use_async) assert cast(Any, params) == {"foo": True} @@ -309,11 +309,11 @@ async def test_pydantic_mismatched_types(use_async: bool) -> None: @pytest.mark.asyncio async def test_pydantic_mismatched_object_type(use_async: bool) -> None: model = MyModel.construct(foo=MyModel.construct(hello="world")) - if PYDANTIC_V2: + if PYDANTIC_V1: + params = await transform(model, Any, use_async) + else: with pytest.warns(UserWarning): params = await transform(model, Any, use_async) - else: - params = await transform(model, Any, use_async) assert cast(Any, params) == {"foo": {"hello": "world"}} diff --git a/tests/test_utils/test_datetime_parse.py b/tests/test_utils/test_datetime_parse.py new file mode 100644 index 00000000..b5515834 --- /dev/null +++ b/tests/test_utils/test_datetime_parse.py @@ -0,0 +1,110 @@ +""" +Copied from https://github.com/pydantic/pydantic/blob/v1.10.22/tests/test_datetime_parse.py +with modifications so it works without pydantic v1 imports. +""" + +from typing import Type, Union +from datetime import date, datetime, timezone, timedelta + +import pytest + +from agentex._utils import parse_date, parse_datetime + + +def create_tz(minutes: int) -> timezone: + return timezone(timedelta(minutes=minutes)) + + +@pytest.mark.parametrize( + "value,result", + [ + # Valid inputs + ("1494012444.883309", date(2017, 5, 5)), + (b"1494012444.883309", date(2017, 5, 5)), + (1_494_012_444.883_309, date(2017, 5, 5)), + ("1494012444", date(2017, 5, 5)), + (1_494_012_444, date(2017, 5, 5)), + (0, date(1970, 1, 1)), + ("2012-04-23", date(2012, 4, 23)), + (b"2012-04-23", date(2012, 4, 23)), + ("2012-4-9", date(2012, 4, 9)), + (date(2012, 4, 9), date(2012, 4, 9)), + (datetime(2012, 4, 9, 12, 15), date(2012, 4, 9)), + # Invalid inputs + ("x20120423", ValueError), + ("2012-04-56", ValueError), + (19_999_999_999, date(2603, 10, 11)), # just before watershed + (20_000_000_001, date(1970, 8, 20)), # just after watershed + (1_549_316_052, date(2019, 2, 4)), # nowish in s + (1_549_316_052_104, date(2019, 2, 4)), # nowish in ms + (1_549_316_052_104_324, date(2019, 2, 4)), # nowish in μs + (1_549_316_052_104_324_096, date(2019, 2, 4)), # nowish in ns + ("infinity", date(9999, 12, 31)), + ("inf", date(9999, 12, 31)), + (float("inf"), date(9999, 12, 31)), + ("infinity ", date(9999, 12, 31)), + (int("1" + "0" * 100), date(9999, 12, 31)), + (1e1000, date(9999, 12, 31)), + ("-infinity", date(1, 1, 1)), + ("-inf", date(1, 1, 1)), + ("nan", ValueError), + ], +) +def test_date_parsing(value: Union[str, bytes, int, float], result: Union[date, Type[Exception]]) -> None: + if type(result) == type and issubclass(result, Exception): # pyright: ignore[reportUnnecessaryIsInstance] + with pytest.raises(result): + parse_date(value) + else: + assert parse_date(value) == result + + +@pytest.mark.parametrize( + "value,result", + [ + # Valid inputs + # values in seconds + ("1494012444.883309", datetime(2017, 5, 5, 19, 27, 24, 883_309, tzinfo=timezone.utc)), + (1_494_012_444.883_309, datetime(2017, 5, 5, 19, 27, 24, 883_309, tzinfo=timezone.utc)), + ("1494012444", datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)), + (b"1494012444", datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)), + (1_494_012_444, datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)), + # values in ms + ("1494012444000.883309", datetime(2017, 5, 5, 19, 27, 24, 883, tzinfo=timezone.utc)), + ("-1494012444000.883309", datetime(1922, 8, 29, 4, 32, 35, 999117, tzinfo=timezone.utc)), + (1_494_012_444_000, datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)), + ("2012-04-23T09:15:00", datetime(2012, 4, 23, 9, 15)), + ("2012-4-9 4:8:16", datetime(2012, 4, 9, 4, 8, 16)), + ("2012-04-23T09:15:00Z", datetime(2012, 4, 23, 9, 15, 0, 0, timezone.utc)), + ("2012-4-9 4:8:16-0320", datetime(2012, 4, 9, 4, 8, 16, 0, create_tz(-200))), + ("2012-04-23T10:20:30.400+02:30", datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(150))), + ("2012-04-23T10:20:30.400+02", datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(120))), + ("2012-04-23T10:20:30.400-02", datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(-120))), + (b"2012-04-23T10:20:30.400-02", datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(-120))), + (datetime(2017, 5, 5), datetime(2017, 5, 5)), + (0, datetime(1970, 1, 1, 0, 0, 0, tzinfo=timezone.utc)), + # Invalid inputs + ("x20120423091500", ValueError), + ("2012-04-56T09:15:90", ValueError), + ("2012-04-23T11:05:00-25:00", ValueError), + (19_999_999_999, datetime(2603, 10, 11, 11, 33, 19, tzinfo=timezone.utc)), # just before watershed + (20_000_000_001, datetime(1970, 8, 20, 11, 33, 20, 1000, tzinfo=timezone.utc)), # just after watershed + (1_549_316_052, datetime(2019, 2, 4, 21, 34, 12, 0, tzinfo=timezone.utc)), # nowish in s + (1_549_316_052_104, datetime(2019, 2, 4, 21, 34, 12, 104_000, tzinfo=timezone.utc)), # nowish in ms + (1_549_316_052_104_324, datetime(2019, 2, 4, 21, 34, 12, 104_324, tzinfo=timezone.utc)), # nowish in μs + (1_549_316_052_104_324_096, datetime(2019, 2, 4, 21, 34, 12, 104_324, tzinfo=timezone.utc)), # nowish in ns + ("infinity", datetime(9999, 12, 31, 23, 59, 59, 999999)), + ("inf", datetime(9999, 12, 31, 23, 59, 59, 999999)), + ("inf ", datetime(9999, 12, 31, 23, 59, 59, 999999)), + (1e50, datetime(9999, 12, 31, 23, 59, 59, 999999)), + (float("inf"), datetime(9999, 12, 31, 23, 59, 59, 999999)), + ("-infinity", datetime(1, 1, 1, 0, 0)), + ("-inf", datetime(1, 1, 1, 0, 0)), + ("nan", ValueError), + ], +) +def test_datetime_parsing(value: Union[str, bytes, int, float], result: Union[datetime, Type[Exception]]) -> None: + if type(result) == type and issubclass(result, Exception): # pyright: ignore[reportUnnecessaryIsInstance] + with pytest.raises(result): + parse_datetime(value) + else: + assert parse_datetime(value) == result diff --git a/tests/utils.py b/tests/utils.py index b1a74ded..f03ee4f3 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -19,7 +19,7 @@ is_annotated_type, is_type_alias_type, ) -from agentex._compat import PYDANTIC_V2, field_outer_type, get_model_fields +from agentex._compat import PYDANTIC_V1, field_outer_type, get_model_fields from agentex._models import BaseModel BaseModelT = TypeVar("BaseModelT", bound=BaseModel) @@ -28,12 +28,12 @@ def assert_matches_model(model: type[BaseModelT], value: BaseModelT, *, path: list[str]) -> bool: for name, field in get_model_fields(model).items(): field_value = getattr(value, name) - if PYDANTIC_V2: - allow_none = False - else: + if PYDANTIC_V1: # in v1 nullability was structured differently # https://docs.pydantic.dev/2.0/migration/#required-optional-and-nullable-fields allow_none = getattr(field, "allow_none", False) + else: + allow_none = False assert_matches_type( field_outer_type(field), From 1b7e2a983ee2acb838643c90cc0207456b5a1b35 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Sep 2025 14:46:30 +0000 Subject: [PATCH 0118/1108] chore(internal): move mypy configurations to `pyproject.toml` file --- mypy.ini | 50 ------------------------------------------------ pyproject.toml | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 52 insertions(+), 50 deletions(-) delete mode 100644 mypy.ini diff --git a/mypy.ini b/mypy.ini deleted file mode 100644 index 91619053..00000000 --- a/mypy.ini +++ /dev/null @@ -1,50 +0,0 @@ -[mypy] -pretty = True -show_error_codes = True - -# Exclude _files.py because mypy isn't smart enough to apply -# the correct type narrowing and as this is an internal module -# it's fine to just use Pyright. -# -# We also exclude our `tests` as mypy doesn't always infer -# types correctly and Pyright will still catch any type errors. -exclude = ^(src/agentex/_files\.py|_dev/.*\.py|tests/.*)$ - -strict_equality = True -implicit_reexport = True -check_untyped_defs = True -no_implicit_optional = True - -warn_return_any = True -warn_unreachable = True -warn_unused_configs = True - -# Turn these options off as it could cause conflicts -# with the Pyright options. -warn_unused_ignores = False -warn_redundant_casts = False - -disallow_any_generics = True -disallow_untyped_defs = True -disallow_untyped_calls = True -disallow_subclassing_any = True -disallow_incomplete_defs = True -disallow_untyped_decorators = True -cache_fine_grained = True - -# By default, mypy reports an error if you assign a value to the result -# of a function call that doesn't return anything. We do this in our test -# cases: -# ``` -# result = ... -# assert result is None -# ``` -# Changing this codegen to make mypy happy would increase complexity -# and would not be worth it. -disable_error_code = func-returns-value,overload-cannot-match - -# https://github.com/python/mypy/issues/12162 -[mypy.overrides] -module = "black.files.*" -ignore_errors = true -ignore_missing_imports = true diff --git a/pyproject.toml b/pyproject.toml index 7a533e31..ee2f597b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -157,6 +157,58 @@ reportOverlappingOverload = false reportImportCycles = false reportPrivateUsage = false +[tool.mypy] +pretty = true +show_error_codes = true + +# Exclude _files.py because mypy isn't smart enough to apply +# the correct type narrowing and as this is an internal module +# it's fine to just use Pyright. +# +# We also exclude our `tests` as mypy doesn't always infer +# types correctly and Pyright will still catch any type errors. +exclude = ['src/agentex/_files.py', '_dev/.*.py', 'tests/.*'] + +strict_equality = true +implicit_reexport = true +check_untyped_defs = true +no_implicit_optional = true + +warn_return_any = true +warn_unreachable = true +warn_unused_configs = true + +# Turn these options off as it could cause conflicts +# with the Pyright options. +warn_unused_ignores = false +warn_redundant_casts = false + +disallow_any_generics = true +disallow_untyped_defs = true +disallow_untyped_calls = true +disallow_subclassing_any = true +disallow_incomplete_defs = true +disallow_untyped_decorators = true +cache_fine_grained = true + +# By default, mypy reports an error if you assign a value to the result +# of a function call that doesn't return anything. We do this in our test +# cases: +# ``` +# result = ... +# assert result is None +# ``` +# Changing this codegen to make mypy happy would increase complexity +# and would not be worth it. +disable_error_code = "func-returns-value,overload-cannot-match" + +# https://github.com/python/mypy/issues/12162 +[[tool.mypy.overrides]] +module = "black.files.*" +ignore_errors = true +ignore_missing_imports = true + + [tool.ruff] line-length = 120 output-format = "grouped" From e22a7df5851d480ccb0319f84792f49a3aab1d61 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Sep 2025 18:19:55 +0000 Subject: [PATCH 0119/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 1538b88f..ee0200c8 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.10" + ".": "0.4.11" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index ee2f597b..022fad65 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.10" +version = "0.4.11" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index dedee372..0cccfb71 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.10" # x-release-please-version +__version__ = "0.4.11" # x-release-please-version From 89f82d22028150bd09113bc1ce9e59cc7749ed1d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 8 Sep 2025 18:06:00 +0000 Subject: [PATCH 0120/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index ee0200c8..c5c833d2 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.11" + ".": "0.4.12" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 022fad65..e5fadfde 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.11" +version = "0.4.12" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 0cccfb71..7ff38883 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.11" # x-release-please-version +__version__ = "0.4.12" # x-release-please-version From af93fdffc51742e52aadf7d23ab4374b6b46ff25 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Sep 2025 17:25:20 +0000 Subject: [PATCH 0121/1108] feat(api): api update --- .stats.yml | 4 ++-- src/agentex/resources/tasks.py | 8 ++++---- src/agentex/types/task.py | 2 ++ 3 files changed, 8 insertions(+), 6 deletions(-) diff --git a/.stats.yml b/.stats.yml index bd1fb205..00687c8b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6eec9554350594d13aa61f6d3c384a54cbaba95481ee06c228a9d0a0aefaeda8.yml -openapi_spec_hash: 63770414d1be9807d9b7ebbef0ae9fee +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4ae441fa9819e53daaaa92486ff99eee5b638eeee7237f535b6de9b53868b6a8.yml +openapi_spec_hash: 05bfd452bc8d456f546a8273bb1718f8 config_hash: aeabb3a919ad2763f5d0f41961a2520a diff --git a/src/agentex/resources/tasks.py b/src/agentex/resources/tasks.py index 5a28465b..031053b6 100644 --- a/src/agentex/resources/tasks.py +++ b/src/agentex/resources/tasks.py @@ -232,7 +232,7 @@ def stream_events( timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, ) -> Stream[object]: """ - Stream message updates for a task by its unique ID. + Stream events for a task by its unique ID. Args: extra_headers: Send extra headers @@ -267,7 +267,7 @@ def stream_events_by_name( timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, ) -> Stream[object]: """ - Stream message updates for a task by its unique name. + Stream events for a task by its unique name. Args: extra_headers: Send extra headers @@ -497,7 +497,7 @@ async def stream_events( timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, ) -> AsyncStream[object]: """ - Stream message updates for a task by its unique ID. + Stream events for a task by its unique ID. Args: extra_headers: Send extra headers @@ -532,7 +532,7 @@ async def stream_events_by_name( timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, ) -> AsyncStream[object]: """ - Stream message updates for a task by its unique name. + Stream events for a task by its unique name. Args: extra_headers: Send extra headers diff --git a/src/agentex/types/task.py b/src/agentex/types/task.py index 710ad445..3b22f819 100644 --- a/src/agentex/types/task.py +++ b/src/agentex/types/task.py @@ -22,4 +22,6 @@ class Task(BaseModel): status_reason: Optional[str] = None + task_metadata: Optional[Dict[str, object]] = None + updated_at: Optional[datetime] = None From fc25ad9452c658963a3422aa607bdedfa0a72777 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Sep 2025 22:25:37 +0000 Subject: [PATCH 0122/1108] feat(api): api update --- .stats.yml | 4 ++-- src/agentex/types/agent.py | 8 +++++++- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/.stats.yml b/.stats.yml index 00687c8b..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4ae441fa9819e53daaaa92486ff99eee5b638eeee7237f535b6de9b53868b6a8.yml -openapi_spec_hash: 05bfd452bc8d456f546a8273bb1718f8 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a diff --git a/src/agentex/types/agent.py b/src/agentex/types/agent.py index 9b921e8e..8dfcac0c 100644 --- a/src/agentex/types/agent.py +++ b/src/agentex/types/agent.py @@ -1,6 +1,6 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Optional +from typing import Dict, Optional from datetime import datetime from typing_extensions import Literal @@ -29,6 +29,12 @@ class Agent(BaseModel): updated_at: datetime """The timestamp when the agent was last updated""" + registered_at: Optional[datetime] = None + """The timestamp when the agent was last registered""" + + registration_metadata: Optional[Dict[str, object]] = None + """The metadata for the agent's registration.""" + status: Optional[Literal["Pending", "Building", "Ready", "Failed", "Unknown"]] = None """The status of the action, indicating if it's building, ready, failed, etc.""" From 81e1578408e34762a5cee7fa0e6618dffd2c649a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Sep 2025 23:25:18 +0000 Subject: [PATCH 0123/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From d34979153c1d8acaf67fc3a31f7a299a70f08af8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 11 Sep 2025 14:25:19 +0000 Subject: [PATCH 0124/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 82b05e8651fd0fe6b55e7e4ac0713e972914030a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 11 Sep 2025 15:25:20 +0000 Subject: [PATCH 0125/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 9f61f553362fbd3c7aefaf24038808d1f45b3736 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 11 Sep 2025 20:25:18 +0000 Subject: [PATCH 0126/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From d4b42f7c6c67c5a05eadf21a944dbb35c1065eb4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 11 Sep 2025 20:47:51 +0000 Subject: [PATCH 0127/1108] chore(internal): codegen related update --- pyproject.toml | 1 - requirements-dev.lock | 1 - tests/test_client.py | 53 +++++-------------------------------------- 3 files changed, 6 insertions(+), 49 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index e5fadfde..7d051fe2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -56,7 +56,6 @@ dev-dependencies = [ "dirty-equals>=0.6.0", "importlib-metadata>=6.7.0", "rich>=13.7.1", - "nest_asyncio==1.6.0", "pytest-xdist>=3.6.1", ] diff --git a/requirements-dev.lock b/requirements-dev.lock index 56a38441..57e5a37b 100644 --- a/requirements-dev.lock +++ b/requirements-dev.lock @@ -75,7 +75,6 @@ multidict==6.4.4 mypy==1.14.1 mypy-extensions==1.0.0 # via mypy -nest-asyncio==1.6.0 nodeenv==1.8.0 # via pyright nox==2023.4.22 diff --git a/tests/test_client.py b/tests/test_client.py index da5399da..32b286d7 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -6,13 +6,10 @@ import os import sys import json -import time import asyncio import inspect -import subprocess import tracemalloc from typing import Any, Union, cast -from textwrap import dedent from unittest import mock from typing_extensions import Literal @@ -23,14 +20,17 @@ from agentex import Agentex, AsyncAgentex, APIResponseValidationError from agentex._types import Omit +from agentex._utils import asyncify from agentex._models import BaseModel, FinalRequestOptions from agentex._exceptions import APIStatusError, APITimeoutError, APIResponseValidationError from agentex._base_client import ( DEFAULT_TIMEOUT, HTTPX_DEFAULT_TIMEOUT, BaseClient, + OtherPlatform, DefaultHttpxClient, DefaultAsyncHttpxClient, + get_platform, make_request_options, ) @@ -1643,50 +1643,9 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: assert response.http_request.headers.get("x-stainless-retry-count") == "42" - def test_get_platform(self) -> None: - # A previous implementation of asyncify could leave threads unterminated when - # used with nest_asyncio. - # - # Since nest_asyncio.apply() is global and cannot be un-applied, this - # test is run in a separate process to avoid affecting other tests. - test_code = dedent(""" - import asyncio - import nest_asyncio - import threading - - from agentex._utils import asyncify - from agentex._base_client import get_platform - - async def test_main() -> None: - result = await asyncify(get_platform)() - print(result) - for thread in threading.enumerate(): - print(thread.name) - - nest_asyncio.apply() - asyncio.run(test_main()) - """) - with subprocess.Popen( - [sys.executable, "-c", test_code], - text=True, - ) as process: - timeout = 10 # seconds - - start_time = time.monotonic() - while True: - return_code = process.poll() - if return_code is not None: - if return_code != 0: - raise AssertionError("calling get_platform using asyncify resulted in a non-zero exit code") - - # success - break - - if time.monotonic() - start_time > timeout: - process.kill() - raise AssertionError("calling get_platform using asyncify resulted in a hung process") - - time.sleep(0.1) + async def test_get_platform(self) -> None: + platform = await asyncify(get_platform)() + assert isinstance(platform, (str, OtherPlatform)) async def test_proxy_environment_variables(self, monkeypatch: pytest.MonkeyPatch) -> None: # Test that the proxy environment variables are set correctly From e47cd325ba5e6a872a01f541cc27bc78ec9a3c53 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Sep 2025 00:25:25 +0000 Subject: [PATCH 0128/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 98a22e50fcaf73152ee63d03e3df2f19f07bf368 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Sep 2025 02:25:24 +0000 Subject: [PATCH 0129/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From db5149a3b49174a481390f772ce891bdbc51f1a1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Sep 2025 03:25:24 +0000 Subject: [PATCH 0130/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 9ced6fbaabce473029448563fb1b9a378233c8c2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Sep 2025 05:25:24 +0000 Subject: [PATCH 0131/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From c08b4c3c1f19cac4d41c9e96c207a8c66536cbf3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Sep 2025 05:25:49 +0000 Subject: [PATCH 0132/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index c5c833d2..a56671ac 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.12" + ".": "0.4.13" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 7d051fe2..e4b752f0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.12" +version = "0.4.13" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 7ff38883..13cf0a6a 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.12" # x-release-please-version +__version__ = "0.4.13" # x-release-please-version From cf100cbe195d9aed09dfb04be52b9cc8c1919a83 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Sep 2025 06:26:06 +0000 Subject: [PATCH 0133/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 5d559ade64c7f215c7716a896468ce5d2214000e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Sep 2025 07:25:25 +0000 Subject: [PATCH 0134/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 987165aa69c30360185612ff7c548c60c7ca6c5d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Sep 2025 09:25:18 +0000 Subject: [PATCH 0135/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 511f4627ec667d2b189da72345a978c9e9c0dbde Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Sep 2025 12:25:17 +0000 Subject: [PATCH 0136/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From d8f177e43bd01b92bfa6bf2bac035cda763bc175 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Sep 2025 13:25:18 +0000 Subject: [PATCH 0137/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From f56a44dea5a1471c0b9c2c511eaf7f80440413ac Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Sep 2025 15:25:19 +0000 Subject: [PATCH 0138/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 321b765b67d041174655cdae796bb63a0e419689 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Sep 2025 17:25:18 +0000 Subject: [PATCH 0139/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 27f023b4e7b1ec58dc5cecf5d85423c0bba1c444 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Sep 2025 20:25:19 +0000 Subject: [PATCH 0140/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 4aa977312df8415923267c86b5aa1b3f0c240993 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Sep 2025 22:25:28 +0000 Subject: [PATCH 0141/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 828868bdf789b2aa2bc644af05cccc42ec722cf8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Sep 2025 23:25:26 +0000 Subject: [PATCH 0142/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From e82dd8d2c1b9d18606fcabd871036aceb94034d8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Sep 2025 03:25:58 +0000 Subject: [PATCH 0143/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 150dc595858401205526ba540833d960f479086a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Sep 2025 05:26:09 +0000 Subject: [PATCH 0144/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From f403a7de82bc280e8a2b8519c982b1ff252725cf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Sep 2025 07:25:52 +0000 Subject: [PATCH 0145/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From ce291cbaec430303ef629251089d473bd1147cb0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Sep 2025 09:25:43 +0000 Subject: [PATCH 0146/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 70412efef6e681191f4b0a8d1b169e324bf51c6c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Sep 2025 11:25:36 +0000 Subject: [PATCH 0147/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From b72837cacb857a73b077142c17afe78029bb76b5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Sep 2025 16:25:32 +0000 Subject: [PATCH 0148/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 49217983b48c8d1daeeedc33938459b1dba9c14a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Sep 2025 18:25:23 +0000 Subject: [PATCH 0149/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 760284c472aec4700d219bebc6d07cd8e56bb998 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Sep 2025 22:25:29 +0000 Subject: [PATCH 0150/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 7c8e74c7326af49ef908bc84940c6af6210287d7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Sep 2025 23:25:32 +0000 Subject: [PATCH 0151/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 110376b4b3a30bec9b77b70d8a29be19017a765c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Sep 2025 04:25:21 +0000 Subject: [PATCH 0152/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 7f87cfc7e9a938321a42434affb134a14f3236bd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Sep 2025 05:25:20 +0000 Subject: [PATCH 0153/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 7793fedc724f88f7d1d0ea06b4eb4c7a07fe3d03 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Sep 2025 06:25:39 +0000 Subject: [PATCH 0154/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 44dbd426565b02001807ca053156cdc2ee72b429 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Sep 2025 07:25:30 +0000 Subject: [PATCH 0155/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From a585a200bd5804e45a28d68cc4baf9370dcce6b5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Sep 2025 08:25:35 +0000 Subject: [PATCH 0156/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 00bf67e08062f59e15483b5107e0f084c8e0e78f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Sep 2025 12:25:37 +0000 Subject: [PATCH 0157/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 50ed57ef0e80f9f77e47f91f5d4eb2f8a514d105 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Sep 2025 14:25:32 +0000 Subject: [PATCH 0158/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From a007803a9f29132cb793c34a70615ff516e53f99 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Sep 2025 16:25:44 +0000 Subject: [PATCH 0159/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From e7fb1caefb0ac4728464aa31f9adef231acd1224 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Sep 2025 18:25:29 +0000 Subject: [PATCH 0160/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 26ed3da50263626dd9aafea0cfd3f0fa1f78ab0d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Sep 2025 19:25:31 +0000 Subject: [PATCH 0161/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 46f0cb6932bf42a2929549083223b593ba40c063 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Sep 2025 20:25:44 +0000 Subject: [PATCH 0162/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From cd18dc0f2c6a9e663f84079302f20a3392fae439 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Sep 2025 22:25:32 +0000 Subject: [PATCH 0163/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 52bb77d360f43c083e876786ba0e934ef939d6ca Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Sep 2025 00:25:27 +0000 Subject: [PATCH 0164/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 3dad9f4c234cb9de99c77bf1ffbb29c804d089ba Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Sep 2025 01:25:29 +0000 Subject: [PATCH 0165/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 7c4a48d1b18b03b896e07a6a7ed1b0620119bed8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Sep 2025 04:25:43 +0000 Subject: [PATCH 0166/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 7dacae6fe5aa716a15fe5924f5f718efe9c52922 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Sep 2025 07:25:36 +0000 Subject: [PATCH 0167/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 227dec1158fb9fab0d8e5717fc1189e7564e3c9f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Sep 2025 08:25:34 +0000 Subject: [PATCH 0168/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From a69d275e217733eee6097fcef8ad890a5f42252f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Sep 2025 14:25:34 +0000 Subject: [PATCH 0169/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 097f66dcab0b3006de53774984c7d37c4af2d0d3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Sep 2025 15:25:33 +0000 Subject: [PATCH 0170/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 37aa991ec6a00b730fdef42cf0d37a4b4dcfae23 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Sep 2025 16:25:38 +0000 Subject: [PATCH 0171/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 3eaf176851e9fe646c50423576e9f4ec36fff7af Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Sep 2025 19:25:31 +0000 Subject: [PATCH 0172/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 44441005a8308502d8ae955abd56a41efae3a911 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 00:40:48 +0000 Subject: [PATCH 0173/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index a56671ac..f597ddce 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.13" + ".": "0.4.14" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index e4b752f0..43b8d9b3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.13" +version = "0.4.14" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 13cf0a6a..210a6863 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.13" # x-release-please-version +__version__ = "0.4.14" # x-release-please-version From e67e2478560c0204e0bce4abf2d9f7562533fa05 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 00:55:42 +0000 Subject: [PATCH 0174/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index f597ddce..ca691fa0 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.14" + ".": "0.4.15" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 43b8d9b3..b27a6419 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.14" +version = "0.4.15" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 210a6863..6a689324 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.14" # x-release-please-version +__version__ = "0.4.15" # x-release-please-version From ddcdf7e6e7cb2c1f4655e68a88853821b8494fc1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 01:34:12 +0000 Subject: [PATCH 0175/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index ca691fa0..3a5048bc 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.15" + ".": "0.4.16" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index b27a6419..4ba5a6c7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.15" +version = "0.4.16" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 6a689324..41412071 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.15" # x-release-please-version +__version__ = "0.4.16" # x-release-please-version From 497d9e965823d1af01ab7db29a9ffa9e208b1f18 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 02:25:26 +0000 Subject: [PATCH 0176/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From e3e0a4928a9bb10b5bef1cc9c323f81f6c6eb4cc Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 06:25:31 +0000 Subject: [PATCH 0177/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 560f13cd727281ef00d2396b67f9ab420153ac28 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 10:25:34 +0000 Subject: [PATCH 0178/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 04e80d00bdd135f65ba2cb5323ad3c1b05594038 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 12:25:36 +0000 Subject: [PATCH 0179/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 2a8f7fdbe9af7c56b8b9fdeed45bba378f4c5a04 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 14:25:35 +0000 Subject: [PATCH 0180/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From cb9586afcbf71049a64a0cbaff31ba78b7a7e1b1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 15:25:36 +0000 Subject: [PATCH 0181/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 315072adfec4c087b5a6d3db369b88043340034b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 16:25:38 +0000 Subject: [PATCH 0182/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From a6a7d32cf634a76d520a433b43e3f0784fc058ea Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 17:25:34 +0000 Subject: [PATCH 0183/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 64895dfd8dd3ae3941909fd42f5a80b67c063ba8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 18:25:28 +0000 Subject: [PATCH 0184/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 4622a2d79653470a47c9231fef3276c8393d4e5c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 19:11:21 +0000 Subject: [PATCH 0185/1108] chore(internal): update pydantic dependency --- requirements-dev.lock | 7 +++++-- requirements.lock | 7 +++++-- src/agentex/_models.py | 14 ++++++++++---- 3 files changed, 20 insertions(+), 8 deletions(-) diff --git a/requirements-dev.lock b/requirements-dev.lock index 57e5a37b..0203ae90 100644 --- a/requirements-dev.lock +++ b/requirements-dev.lock @@ -88,9 +88,9 @@ pluggy==1.5.0 propcache==0.3.1 # via aiohttp # via yarl -pydantic==2.10.3 +pydantic==2.11.9 # via agentex-sdk -pydantic-core==2.27.1 +pydantic-core==2.33.2 # via pydantic pygments==2.18.0 # via rich @@ -126,6 +126,9 @@ typing-extensions==4.12.2 # via pydantic # via pydantic-core # via pyright + # via typing-inspection +typing-inspection==0.4.1 + # via pydantic virtualenv==20.24.5 # via nox yarl==1.20.0 diff --git a/requirements.lock b/requirements.lock index a4e7e943..a78ce137 100644 --- a/requirements.lock +++ b/requirements.lock @@ -55,9 +55,9 @@ multidict==6.4.4 propcache==0.3.1 # via aiohttp # via yarl -pydantic==2.10.3 +pydantic==2.11.9 # via agentex-sdk -pydantic-core==2.27.1 +pydantic-core==2.33.2 # via pydantic sniffio==1.3.0 # via agentex-sdk @@ -68,5 +68,8 @@ typing-extensions==4.12.2 # via multidict # via pydantic # via pydantic-core + # via typing-inspection +typing-inspection==0.4.1 + # via pydantic yarl==1.20.0 # via aiohttp diff --git a/src/agentex/_models.py b/src/agentex/_models.py index 3a6017ef..6a3cd1d2 100644 --- a/src/agentex/_models.py +++ b/src/agentex/_models.py @@ -256,7 +256,7 @@ def model_dump( mode: Literal["json", "python"] | str = "python", include: IncEx | None = None, exclude: IncEx | None = None, - by_alias: bool = False, + by_alias: bool | None = None, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, @@ -264,6 +264,7 @@ def model_dump( warnings: bool | Literal["none", "warn", "error"] = True, context: dict[str, Any] | None = None, serialize_as_any: bool = False, + fallback: Callable[[Any], Any] | None = None, ) -> dict[str, Any]: """Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#modelmodel_dump @@ -295,10 +296,12 @@ def model_dump( raise ValueError("context is only supported in Pydantic v2") if serialize_as_any != False: raise ValueError("serialize_as_any is only supported in Pydantic v2") + if fallback is not None: + raise ValueError("fallback is only supported in Pydantic v2") dumped = super().dict( # pyright: ignore[reportDeprecated] include=include, exclude=exclude, - by_alias=by_alias, + by_alias=by_alias if by_alias is not None else False, exclude_unset=exclude_unset, exclude_defaults=exclude_defaults, exclude_none=exclude_none, @@ -313,13 +316,14 @@ def model_dump_json( indent: int | None = None, include: IncEx | None = None, exclude: IncEx | None = None, - by_alias: bool = False, + by_alias: bool | None = None, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, round_trip: bool = False, warnings: bool | Literal["none", "warn", "error"] = True, context: dict[str, Any] | None = None, + fallback: Callable[[Any], Any] | None = None, serialize_as_any: bool = False, ) -> str: """Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#modelmodel_dump_json @@ -348,11 +352,13 @@ def model_dump_json( raise ValueError("context is only supported in Pydantic v2") if serialize_as_any != False: raise ValueError("serialize_as_any is only supported in Pydantic v2") + if fallback is not None: + raise ValueError("fallback is only supported in Pydantic v2") return super().json( # type: ignore[reportDeprecated] indent=indent, include=include, exclude=exclude, - by_alias=by_alias, + by_alias=by_alias if by_alias is not None else False, exclude_unset=exclude_unset, exclude_defaults=exclude_defaults, exclude_none=exclude_none, From 8da25537878d2c4a86ab8058d3b65c0bfa701457 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 19:25:31 +0000 Subject: [PATCH 0186/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From b18d2f3ab4d5c8f07cd3648f2c0c0d6bbeebca33 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 22:25:30 +0000 Subject: [PATCH 0187/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From a4604e967d2d504d47cf114e9d716d410a33a69c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 23:25:41 +0000 Subject: [PATCH 0188/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 5bb9e432360b9e60d7194fa91a28a5d3d79951be Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 17 Sep 2025 00:25:38 +0000 Subject: [PATCH 0189/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 2c216aaf0a351a0cf8b5795d15d880114e977c8f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 17 Sep 2025 01:25:39 +0000 Subject: [PATCH 0190/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 56cac74c231d006bee2f75e33057395c2328e15d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 17 Sep 2025 02:25:35 +0000 Subject: [PATCH 0191/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 9604de27f59610c66defc9474a807a777a21cd3a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 17 Sep 2025 03:25:35 +0000 Subject: [PATCH 0192/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 62dbf8a6c7c4b5d49065fe33579bd5fd1c06f7de Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 17 Sep 2025 06:25:31 +0000 Subject: [PATCH 0193/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 47416b11b0e1062ff959f1fb42efa4c0700cffa3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 17 Sep 2025 11:25:36 +0000 Subject: [PATCH 0194/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 21350d354d8dfce5c6dd110a8b26f3cb04656c4a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 17 Sep 2025 12:25:35 +0000 Subject: [PATCH 0195/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From d8b89c2c3cc919031ab1907cde5c1e0ea93bc193 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 17 Sep 2025 13:25:35 +0000 Subject: [PATCH 0196/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From decf62277de02a11e8f1e40c0ced2e91011cedf8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 17 Sep 2025 14:25:29 +0000 Subject: [PATCH 0197/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 15cbf7c610de5b8b4bedf3d9c0aab920ba73df91 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 17 Sep 2025 15:25:28 +0000 Subject: [PATCH 0198/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From f707aa9e8a71b36d58a21d067b39d2bd24634484 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 17 Sep 2025 18:25:29 +0000 Subject: [PATCH 0199/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From afed24b2ea3afd15ba3313be472871f7727c8de1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 17 Sep 2025 19:25:36 +0000 Subject: [PATCH 0200/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 4f023e25f0fba293fca56221e5583497f762f9d0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Sep 2025 05:25:37 +0000 Subject: [PATCH 0201/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 2a9124a8bdcf89c7d41c0ba3169ea34a82526d69 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Sep 2025 06:25:36 +0000 Subject: [PATCH 0202/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 544d23f273c521e3ac9a0f1281a9e5a584a2921f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Sep 2025 07:25:33 +0000 Subject: [PATCH 0203/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 7ba031856c4b4ddf54294bf2cc5f5a154bebe68d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Sep 2025 08:25:35 +0000 Subject: [PATCH 0204/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From ae73554dfae85ee5c8fc6f605edf183a4b81786f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Sep 2025 11:25:37 +0000 Subject: [PATCH 0205/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 1d406b5b217c468b8c58494f005ec17dfa958449 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Sep 2025 14:25:37 +0000 Subject: [PATCH 0206/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 9bde62562310a299e4298c6ce2f77ec2a9f0283c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Sep 2025 14:56:14 +0000 Subject: [PATCH 0207/1108] chore(types): change optional parameter type from NotGiven to Omit --- src/agentex/__init__.py | 4 +- src/agentex/_base_client.py | 18 ++--- src/agentex/_client.py | 24 +++---- src/agentex/_qs.py | 14 ++-- src/agentex/_types.py | 29 +++++--- src/agentex/_utils/_transform.py | 4 +- src/agentex/_utils/_utils.py | 8 +-- src/agentex/resources/agents.py | 50 +++++++------- src/agentex/resources/events.py | 18 ++--- src/agentex/resources/messages/batch.py | 10 +-- src/agentex/resources/messages/messages.py | 30 ++++----- src/agentex/resources/spans.py | 78 +++++++++++----------- src/agentex/resources/states.py | 30 ++++----- src/agentex/resources/tasks.py | 38 +++++------ src/agentex/resources/tracker.py | 34 +++++----- tests/test_transform.py | 11 ++- 16 files changed, 208 insertions(+), 192 deletions(-) diff --git a/src/agentex/__init__.py b/src/agentex/__init__.py index 50fd7ec6..772c2c0f 100644 --- a/src/agentex/__init__.py +++ b/src/agentex/__init__.py @@ -3,7 +3,7 @@ import typing as _t from . import types -from ._types import NOT_GIVEN, Omit, NoneType, NotGiven, Transport, ProxiesTypes +from ._types import NOT_GIVEN, Omit, NoneType, NotGiven, Transport, ProxiesTypes, omit, not_given from ._utils import file_from_path from ._client import ( ENVIRONMENTS, @@ -49,7 +49,9 @@ "ProxiesTypes", "NotGiven", "NOT_GIVEN", + "not_given", "Omit", + "omit", "AgentexError", "APIError", "APIStatusError", diff --git a/src/agentex/_base_client.py b/src/agentex/_base_client.py index df53be60..108a8a52 100644 --- a/src/agentex/_base_client.py +++ b/src/agentex/_base_client.py @@ -42,7 +42,6 @@ from ._qs import Querystring from ._files import to_httpx_files, async_to_httpx_files from ._types import ( - NOT_GIVEN, Body, Omit, Query, @@ -57,6 +56,7 @@ RequestOptions, HttpxRequestFiles, ModelBuilderProtocol, + not_given, ) from ._utils import is_dict, is_list, asyncify, is_given, lru_cache, is_mapping from ._compat import PYDANTIC_V1, model_copy, model_dump @@ -145,9 +145,9 @@ def __init__( def __init__( self, *, - url: URL | NotGiven = NOT_GIVEN, - json: Body | NotGiven = NOT_GIVEN, - params: Query | NotGiven = NOT_GIVEN, + url: URL | NotGiven = not_given, + json: Body | NotGiven = not_given, + params: Query | NotGiven = not_given, ) -> None: self.url = url self.json = json @@ -595,7 +595,7 @@ def _maybe_override_cast_to(self, cast_to: type[ResponseT], options: FinalReques # we internally support defining a temporary header to override the # default `cast_to` type for use with `.with_raw_response` and `.with_streaming_response` # see _response.py for implementation details - override_cast_to = headers.pop(OVERRIDE_CAST_TO_HEADER, NOT_GIVEN) + override_cast_to = headers.pop(OVERRIDE_CAST_TO_HEADER, not_given) if is_given(override_cast_to): options.headers = headers return cast(Type[ResponseT], override_cast_to) @@ -825,7 +825,7 @@ def __init__( version: str, base_url: str | URL, max_retries: int = DEFAULT_MAX_RETRIES, - timeout: float | Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | Timeout | None | NotGiven = not_given, http_client: httpx.Client | None = None, custom_headers: Mapping[str, str] | None = None, custom_query: Mapping[str, object] | None = None, @@ -1356,7 +1356,7 @@ def __init__( base_url: str | URL, _strict_response_validation: bool, max_retries: int = DEFAULT_MAX_RETRIES, - timeout: float | Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | Timeout | None | NotGiven = not_given, http_client: httpx.AsyncClient | None = None, custom_headers: Mapping[str, str] | None = None, custom_query: Mapping[str, object] | None = None, @@ -1818,8 +1818,8 @@ def make_request_options( extra_query: Query | None = None, extra_body: Body | None = None, idempotency_key: str | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - post_parser: PostParser | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + post_parser: PostParser | NotGiven = not_given, ) -> RequestOptions: """Create a dict of type RequestOptions without keys of NotGiven values.""" options: RequestOptions = {} diff --git a/src/agentex/_client.py b/src/agentex/_client.py index 51ebb5e8..a87f6cbf 100644 --- a/src/agentex/_client.py +++ b/src/agentex/_client.py @@ -3,7 +3,7 @@ from __future__ import annotations import os -from typing import Any, Dict, Union, Mapping, cast +from typing import Any, Dict, Mapping, cast from typing_extensions import Self, Literal, override import httpx @@ -11,13 +11,13 @@ from . import _exceptions from ._qs import Querystring from ._types import ( - NOT_GIVEN, Omit, Timeout, NotGiven, Transport, ProxiesTypes, RequestOptions, + not_given, ) from ._utils import is_given, get_async_library from ._version import __version__ @@ -69,9 +69,9 @@ def __init__( self, *, api_key: str | None = None, - environment: Literal["production", "development"] | NotGiven = NOT_GIVEN, - base_url: str | httpx.URL | None | NotGiven = NOT_GIVEN, - timeout: Union[float, Timeout, None, NotGiven] = NOT_GIVEN, + environment: Literal["production", "development"] | NotGiven = not_given, + base_url: str | httpx.URL | None | NotGiven = not_given, + timeout: float | Timeout | None | NotGiven = not_given, max_retries: int = DEFAULT_MAX_RETRIES, default_headers: Mapping[str, str] | None = None, default_query: Mapping[str, object] | None = None, @@ -172,9 +172,9 @@ def copy( api_key: str | None = None, environment: Literal["production", "development"] | None = None, base_url: str | httpx.URL | None = None, - timeout: float | Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | Timeout | None | NotGiven = not_given, http_client: httpx.Client | None = None, - max_retries: int | NotGiven = NOT_GIVEN, + max_retries: int | NotGiven = not_given, default_headers: Mapping[str, str] | None = None, set_default_headers: Mapping[str, str] | None = None, default_query: Mapping[str, object] | None = None, @@ -273,9 +273,9 @@ def __init__( self, *, api_key: str | None = None, - environment: Literal["production", "development"] | NotGiven = NOT_GIVEN, - base_url: str | httpx.URL | None | NotGiven = NOT_GIVEN, - timeout: Union[float, Timeout, None, NotGiven] = NOT_GIVEN, + environment: Literal["production", "development"] | NotGiven = not_given, + base_url: str | httpx.URL | None | NotGiven = not_given, + timeout: float | Timeout | None | NotGiven = not_given, max_retries: int = DEFAULT_MAX_RETRIES, default_headers: Mapping[str, str] | None = None, default_query: Mapping[str, object] | None = None, @@ -376,9 +376,9 @@ def copy( api_key: str | None = None, environment: Literal["production", "development"] | None = None, base_url: str | httpx.URL | None = None, - timeout: float | Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | Timeout | None | NotGiven = not_given, http_client: httpx.AsyncClient | None = None, - max_retries: int | NotGiven = NOT_GIVEN, + max_retries: int | NotGiven = not_given, default_headers: Mapping[str, str] | None = None, set_default_headers: Mapping[str, str] | None = None, default_query: Mapping[str, object] | None = None, diff --git a/src/agentex/_qs.py b/src/agentex/_qs.py index 274320ca..ada6fd3f 100644 --- a/src/agentex/_qs.py +++ b/src/agentex/_qs.py @@ -4,7 +4,7 @@ from urllib.parse import parse_qs, urlencode from typing_extensions import Literal, get_args -from ._types import NOT_GIVEN, NotGiven, NotGivenOr +from ._types import NotGiven, not_given from ._utils import flatten _T = TypeVar("_T") @@ -41,8 +41,8 @@ def stringify( self, params: Params, *, - array_format: NotGivenOr[ArrayFormat] = NOT_GIVEN, - nested_format: NotGivenOr[NestedFormat] = NOT_GIVEN, + array_format: ArrayFormat | NotGiven = not_given, + nested_format: NestedFormat | NotGiven = not_given, ) -> str: return urlencode( self.stringify_items( @@ -56,8 +56,8 @@ def stringify_items( self, params: Params, *, - array_format: NotGivenOr[ArrayFormat] = NOT_GIVEN, - nested_format: NotGivenOr[NestedFormat] = NOT_GIVEN, + array_format: ArrayFormat | NotGiven = not_given, + nested_format: NestedFormat | NotGiven = not_given, ) -> list[tuple[str, str]]: opts = Options( qs=self, @@ -143,8 +143,8 @@ def __init__( self, qs: Querystring = _qs, *, - array_format: NotGivenOr[ArrayFormat] = NOT_GIVEN, - nested_format: NotGivenOr[NestedFormat] = NOT_GIVEN, + array_format: ArrayFormat | NotGiven = not_given, + nested_format: NestedFormat | NotGiven = not_given, ) -> None: self.array_format = qs.array_format if isinstance(array_format, NotGiven) else array_format self.nested_format = qs.nested_format if isinstance(nested_format, NotGiven) else nested_format diff --git a/src/agentex/_types.py b/src/agentex/_types.py index 002a10d8..e546d27f 100644 --- a/src/agentex/_types.py +++ b/src/agentex/_types.py @@ -117,18 +117,21 @@ class RequestOptions(TypedDict, total=False): # Sentinel class used until PEP 0661 is accepted class NotGiven: """ - A sentinel singleton class used to distinguish omitted keyword arguments - from those passed in with the value None (which may have different behavior). + For parameters with a meaningful None value, we need to distinguish between + the user explicitly passing None, and the user not passing the parameter at + all. + + User code shouldn't need to use not_given directly. For example: ```py - def get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: ... + def create(timeout: Timeout | None | NotGiven = not_given): ... - get(timeout=1) # 1s timeout - get(timeout=None) # No timeout - get() # Default timeout behavior, which may not be statically known at the method definition. + create(timeout=1) # 1s timeout + create(timeout=None) # No timeout + create() # Default timeout behavior ``` """ @@ -140,13 +143,14 @@ def __repr__(self) -> str: return "NOT_GIVEN" -NotGivenOr = Union[_T, NotGiven] +not_given = NotGiven() +# for backwards compatibility: NOT_GIVEN = NotGiven() class Omit: - """In certain situations you need to be able to represent a case where a default value has - to be explicitly removed and `None` is not an appropriate substitute, for example: + """ + To explicitly omit something from being sent in a request, use `omit`. ```py # as the default `Content-Type` header is `application/json` that will be sent @@ -156,8 +160,8 @@ class Omit: # to look something like: 'multipart/form-data; boundary=0d8382fcf5f8c3be01ca2e11002d2983' client.post(..., headers={"Content-Type": "multipart/form-data"}) - # instead you can remove the default `application/json` header by passing Omit - client.post(..., headers={"Content-Type": Omit()}) + # instead you can remove the default `application/json` header by passing omit + client.post(..., headers={"Content-Type": omit}) ``` """ @@ -165,6 +169,9 @@ def __bool__(self) -> Literal[False]: return False +omit = Omit() + + @runtime_checkable class ModelBuilderProtocol(Protocol): @classmethod diff --git a/src/agentex/_utils/_transform.py b/src/agentex/_utils/_transform.py index c19124f0..52075492 100644 --- a/src/agentex/_utils/_transform.py +++ b/src/agentex/_utils/_transform.py @@ -268,7 +268,7 @@ def _transform_typeddict( annotations = get_type_hints(expected_type, include_extras=True) for key, value in data.items(): if not is_given(value): - # we don't need to include `NotGiven` values here as they'll + # we don't need to include omitted values here as they'll # be stripped out before the request is sent anyway continue @@ -434,7 +434,7 @@ async def _async_transform_typeddict( annotations = get_type_hints(expected_type, include_extras=True) for key, value in data.items(): if not is_given(value): - # we don't need to include `NotGiven` values here as they'll + # we don't need to include omitted values here as they'll # be stripped out before the request is sent anyway continue diff --git a/src/agentex/_utils/_utils.py b/src/agentex/_utils/_utils.py index f0818595..50d59269 100644 --- a/src/agentex/_utils/_utils.py +++ b/src/agentex/_utils/_utils.py @@ -21,7 +21,7 @@ import sniffio -from .._types import NotGiven, FileTypes, NotGivenOr, HeadersLike +from .._types import Omit, NotGiven, FileTypes, HeadersLike _T = TypeVar("_T") _TupleT = TypeVar("_TupleT", bound=Tuple[object, ...]) @@ -63,7 +63,7 @@ def _extract_items( try: key = path[index] except IndexError: - if isinstance(obj, NotGiven): + if not is_given(obj): # no value was provided - we can safely ignore return [] @@ -126,8 +126,8 @@ def _extract_items( return [] -def is_given(obj: NotGivenOr[_T]) -> TypeGuard[_T]: - return not isinstance(obj, NotGiven) +def is_given(obj: _T | NotGiven | Omit) -> TypeGuard[_T]: + return not isinstance(obj, NotGiven) and not isinstance(obj, Omit) # Type safe methods for narrowing types with TypeVars. diff --git a/src/agentex/resources/agents.py b/src/agentex/resources/agents.py index ea563f91..e59abae2 100644 --- a/src/agentex/resources/agents.py +++ b/src/agentex/resources/agents.py @@ -8,7 +8,7 @@ import httpx from ..types import agent_rpc_params, agent_list_params, agent_rpc_by_name_params -from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property from .._resource import SyncAPIResource, AsyncAPIResource @@ -56,7 +56,7 @@ def retrieve( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Agent: """ Get an agent by its unique ID. @@ -83,13 +83,13 @@ def retrieve( def list( self, *, - task_id: Optional[str] | NotGiven = NOT_GIVEN, + task_id: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> AgentListResponse: """ List all registered agents, optionally filtered by query parameters. @@ -126,7 +126,7 @@ def delete( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> DeleteResponse: """ Delete an agent by its unique ID. @@ -159,7 +159,7 @@ def delete_by_name( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> DeleteResponse: """ Delete an agent by its unique name. @@ -192,7 +192,7 @@ def retrieve_by_name( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Agent: """ Get an agent by its unique name. @@ -222,14 +222,14 @@ def rpc( *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], params: agent_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + id: Union[int, str, None] | Omit = omit, + jsonrpc: Literal["2.0"] | 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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> AgentRpcResponse: """ Handle JSON-RPC requests for an agent by its unique ID. @@ -270,14 +270,14 @@ def rpc_by_name( *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], params: agent_rpc_by_name_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + id: Union[int, str, None] | Omit = omit, + jsonrpc: Literal["2.0"] | 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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> AgentRpcResponse: """ Handle JSON-RPC requests for an agent by its unique name. @@ -342,7 +342,7 @@ async def retrieve( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Agent: """ Get an agent by its unique ID. @@ -369,13 +369,13 @@ async def retrieve( async def list( self, *, - task_id: Optional[str] | NotGiven = NOT_GIVEN, + task_id: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> AgentListResponse: """ List all registered agents, optionally filtered by query parameters. @@ -412,7 +412,7 @@ async def delete( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> DeleteResponse: """ Delete an agent by its unique ID. @@ -445,7 +445,7 @@ async def delete_by_name( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> DeleteResponse: """ Delete an agent by its unique name. @@ -478,7 +478,7 @@ async def retrieve_by_name( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Agent: """ Get an agent by its unique name. @@ -508,14 +508,14 @@ async def rpc( *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], params: agent_rpc_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + id: Union[int, str, None] | Omit = omit, + jsonrpc: Literal["2.0"] | 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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> AgentRpcResponse: """ Handle JSON-RPC requests for an agent by its unique ID. @@ -556,14 +556,14 @@ async def rpc_by_name( *, method: Literal["event/send", "task/create", "message/send", "task/cancel"], params: agent_rpc_by_name_params.Params, - id: Union[int, str, None] | NotGiven = NOT_GIVEN, - jsonrpc: Literal["2.0"] | NotGiven = NOT_GIVEN, + id: Union[int, str, None] | Omit = omit, + jsonrpc: Literal["2.0"] | 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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> AgentRpcResponse: """ Handle JSON-RPC requests for an agent by its unique name. diff --git a/src/agentex/resources/events.py b/src/agentex/resources/events.py index 79f6fa1b..f6740590 100644 --- a/src/agentex/resources/events.py +++ b/src/agentex/resources/events.py @@ -7,7 +7,7 @@ import httpx from ..types import event_list_params -from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property from .._resource import SyncAPIResource, AsyncAPIResource @@ -53,7 +53,7 @@ def retrieve( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Event: """ Get Event @@ -82,14 +82,14 @@ def list( *, agent_id: str, task_id: str, - last_processed_event_id: Optional[str] | NotGiven = NOT_GIVEN, - limit: Optional[int] | NotGiven = NOT_GIVEN, + last_processed_event_id: Optional[str] | Omit = omit, + limit: Optional[int] | 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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> EventListResponse: """ List events for a specific task and agent. @@ -164,7 +164,7 @@ async def retrieve( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Event: """ Get Event @@ -193,14 +193,14 @@ async def list( *, agent_id: str, task_id: str, - last_processed_event_id: Optional[str] | NotGiven = NOT_GIVEN, - limit: Optional[int] | NotGiven = NOT_GIVEN, + last_processed_event_id: Optional[str] | Omit = omit, + limit: Optional[int] | 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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> EventListResponse: """ List events for a specific task and agent. diff --git a/src/agentex/resources/messages/batch.py b/src/agentex/resources/messages/batch.py index 58412663..f6c06ced 100644 --- a/src/agentex/resources/messages/batch.py +++ b/src/agentex/resources/messages/batch.py @@ -6,7 +6,7 @@ import httpx -from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._types import Body, Query, Headers, NotGiven, not_given from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property from ..._resource import SyncAPIResource, AsyncAPIResource @@ -55,7 +55,7 @@ def create( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> BatchCreateResponse: """ Batch Create Messages @@ -94,7 +94,7 @@ def update( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> BatchUpdateResponse: """ Batch Update Messages @@ -154,7 +154,7 @@ async def create( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> BatchCreateResponse: """ Batch Create Messages @@ -193,7 +193,7 @@ async def update( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> BatchUpdateResponse: """ Batch Update Messages diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index d85f63e1..a3b856d9 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -16,7 +16,7 @@ AsyncBatchResourceWithStreamingResponse, ) from ...types import message_list_params, message_create_params, message_update_params -from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property from ..._resource import SyncAPIResource, AsyncAPIResource @@ -63,13 +63,13 @@ def create( *, content: TaskMessageContentParam, task_id: str, - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | 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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> TaskMessage: """ Create Message @@ -108,7 +108,7 @@ def retrieve( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> TaskMessage: """ Get Message @@ -138,13 +138,13 @@ def update( *, content: TaskMessageContentParam, task_id: str, - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | 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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> TaskMessage: """ Update Message @@ -180,13 +180,13 @@ def list( self, *, task_id: str, - limit: Optional[int] | NotGiven = NOT_GIVEN, + limit: Optional[int] | 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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ List Messages @@ -250,13 +250,13 @@ async def create( *, content: TaskMessageContentParam, task_id: str, - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | 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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> TaskMessage: """ Create Message @@ -295,7 +295,7 @@ async def retrieve( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> TaskMessage: """ Get Message @@ -325,13 +325,13 @@ async def update( *, content: TaskMessageContentParam, task_id: str, - streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | NotGiven = NOT_GIVEN, + streaming_status: Optional[Literal["IN_PROGRESS", "DONE"]] | 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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> TaskMessage: """ Update Message @@ -367,13 +367,13 @@ async def list( self, *, task_id: str, - limit: Optional[int] | NotGiven = NOT_GIVEN, + limit: Optional[int] | 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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ List Messages diff --git a/src/agentex/resources/spans.py b/src/agentex/resources/spans.py index 00327697..d88ed9e7 100644 --- a/src/agentex/resources/spans.py +++ b/src/agentex/resources/spans.py @@ -8,7 +8,7 @@ import httpx from ..types import span_list_params, span_create_params, span_update_params -from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property from .._resource import SyncAPIResource, AsyncAPIResource @@ -51,18 +51,18 @@ def create( name: str, start_time: Union[str, datetime], trace_id: str, - id: Optional[str] | NotGiven = NOT_GIVEN, - data: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, - end_time: Union[str, datetime, None] | NotGiven = NOT_GIVEN, - input: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, - output: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, - parent_id: Optional[str] | NotGiven = NOT_GIVEN, + id: Optional[str] | Omit = omit, + data: Union[Dict[str, object], Iterable[Dict[str, object]], None] | Omit = omit, + end_time: Union[str, datetime, None] | Omit = omit, + input: Union[Dict[str, object], Iterable[Dict[str, object]], None] | Omit = omit, + output: Union[Dict[str, object], Iterable[Dict[str, object]], None] | Omit = omit, + parent_id: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Span: """ Create a new span with the provided parameters @@ -125,7 +125,7 @@ def retrieve( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Span: """ Get a span by ID @@ -153,20 +153,20 @@ def update( self, span_id: str, *, - data: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, - end_time: Union[str, datetime, None] | NotGiven = NOT_GIVEN, - input: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, - name: Optional[str] | NotGiven = NOT_GIVEN, - output: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, - parent_id: Optional[str] | NotGiven = NOT_GIVEN, - start_time: Union[str, datetime, None] | NotGiven = NOT_GIVEN, - trace_id: Optional[str] | NotGiven = NOT_GIVEN, + data: Union[Dict[str, object], Iterable[Dict[str, object]], None] | Omit = omit, + end_time: Union[str, datetime, None] | Omit = omit, + input: Union[Dict[str, object], Iterable[Dict[str, object]], None] | Omit = omit, + name: Optional[str] | Omit = omit, + output: Union[Dict[str, object], Iterable[Dict[str, object]], None] | Omit = omit, + parent_id: Optional[str] | Omit = omit, + start_time: Union[str, datetime, None] | Omit = omit, + trace_id: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Span: """ Update a span with the provided output data and mark it as complete @@ -222,13 +222,13 @@ def update( def list( self, *, - trace_id: Optional[str] | NotGiven = NOT_GIVEN, + trace_id: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> SpanListResponse: """ List all spans for a given trace ID @@ -281,18 +281,18 @@ async def create( name: str, start_time: Union[str, datetime], trace_id: str, - id: Optional[str] | NotGiven = NOT_GIVEN, - data: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, - end_time: Union[str, datetime, None] | NotGiven = NOT_GIVEN, - input: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, - output: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, - parent_id: Optional[str] | NotGiven = NOT_GIVEN, + id: Optional[str] | Omit = omit, + data: Union[Dict[str, object], Iterable[Dict[str, object]], None] | Omit = omit, + end_time: Union[str, datetime, None] | Omit = omit, + input: Union[Dict[str, object], Iterable[Dict[str, object]], None] | Omit = omit, + output: Union[Dict[str, object], Iterable[Dict[str, object]], None] | Omit = omit, + parent_id: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Span: """ Create a new span with the provided parameters @@ -355,7 +355,7 @@ async def retrieve( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Span: """ Get a span by ID @@ -383,20 +383,20 @@ async def update( self, span_id: str, *, - data: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, - end_time: Union[str, datetime, None] | NotGiven = NOT_GIVEN, - input: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, - name: Optional[str] | NotGiven = NOT_GIVEN, - output: Union[Dict[str, object], Iterable[Dict[str, object]], None] | NotGiven = NOT_GIVEN, - parent_id: Optional[str] | NotGiven = NOT_GIVEN, - start_time: Union[str, datetime, None] | NotGiven = NOT_GIVEN, - trace_id: Optional[str] | NotGiven = NOT_GIVEN, + data: Union[Dict[str, object], Iterable[Dict[str, object]], None] | Omit = omit, + end_time: Union[str, datetime, None] | Omit = omit, + input: Union[Dict[str, object], Iterable[Dict[str, object]], None] | Omit = omit, + name: Optional[str] | Omit = omit, + output: Union[Dict[str, object], Iterable[Dict[str, object]], None] | Omit = omit, + parent_id: Optional[str] | Omit = omit, + start_time: Union[str, datetime, None] | Omit = omit, + trace_id: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Span: """ Update a span with the provided output data and mark it as complete @@ -452,13 +452,13 @@ async def update( async def list( self, *, - trace_id: Optional[str] | NotGiven = NOT_GIVEN, + trace_id: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> SpanListResponse: """ List all spans for a given trace ID diff --git a/src/agentex/resources/states.py b/src/agentex/resources/states.py index 6147890a..3100adba 100644 --- a/src/agentex/resources/states.py +++ b/src/agentex/resources/states.py @@ -7,7 +7,7 @@ import httpx from ..types import state_list_params, state_create_params, state_update_params -from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property from .._resource import SyncAPIResource, AsyncAPIResource @@ -55,7 +55,7 @@ def create( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> State: """ Create Task State @@ -94,7 +94,7 @@ def retrieve( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> State: """ Get a state by its unique state ID. @@ -130,7 +130,7 @@ def update( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> State: """ Update Task State @@ -165,14 +165,14 @@ def update( def list( self, *, - agent_id: Optional[str] | NotGiven = NOT_GIVEN, - task_id: Optional[str] | NotGiven = NOT_GIVEN, + agent_id: Optional[str] | Omit = omit, + task_id: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> StateListResponse: """ List all states, optionally filtered by query parameters. @@ -217,7 +217,7 @@ def delete( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> State: """ Delete Task State @@ -273,7 +273,7 @@ async def create( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> State: """ Create Task State @@ -312,7 +312,7 @@ async def retrieve( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> State: """ Get a state by its unique state ID. @@ -348,7 +348,7 @@ async def update( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> State: """ Update Task State @@ -383,14 +383,14 @@ async def update( async def list( self, *, - agent_id: Optional[str] | NotGiven = NOT_GIVEN, - task_id: Optional[str] | NotGiven = NOT_GIVEN, + agent_id: Optional[str] | Omit = omit, + task_id: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> StateListResponse: """ List all states, optionally filtered by query parameters. @@ -435,7 +435,7 @@ async def delete( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> State: """ Delete Task State diff --git a/src/agentex/resources/tasks.py b/src/agentex/resources/tasks.py index 031053b6..0a12e8c3 100644 --- a/src/agentex/resources/tasks.py +++ b/src/agentex/resources/tasks.py @@ -7,7 +7,7 @@ import httpx from ..types import task_list_params -from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property from .._resource import SyncAPIResource, AsyncAPIResource @@ -55,7 +55,7 @@ def retrieve( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Task: """ Get a task by its unique ID. @@ -82,14 +82,14 @@ def retrieve( def list( self, *, - agent_id: Optional[str] | NotGiven = NOT_GIVEN, - agent_name: Optional[str] | NotGiven = NOT_GIVEN, + agent_id: Optional[str] | Omit = omit, + agent_name: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> TaskListResponse: """ List all tasks. @@ -130,7 +130,7 @@ def delete( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> DeleteResponse: """ Delete a task by its unique ID. @@ -163,7 +163,7 @@ def delete_by_name( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> DeleteResponse: """ Delete a task by its unique name. @@ -196,7 +196,7 @@ def retrieve_by_name( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Task: """ Get a task by its unique name. @@ -229,7 +229,7 @@ def stream_events( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Stream[object]: """ Stream events for a task by its unique ID. @@ -264,7 +264,7 @@ def stream_events_by_name( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Stream[object]: """ Stream events for a task by its unique name. @@ -320,7 +320,7 @@ async def retrieve( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Task: """ Get a task by its unique ID. @@ -347,14 +347,14 @@ async def retrieve( async def list( self, *, - agent_id: Optional[str] | NotGiven = NOT_GIVEN, - agent_name: Optional[str] | NotGiven = NOT_GIVEN, + agent_id: Optional[str] | Omit = omit, + agent_name: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> TaskListResponse: """ List all tasks. @@ -395,7 +395,7 @@ async def delete( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> DeleteResponse: """ Delete a task by its unique ID. @@ -428,7 +428,7 @@ async def delete_by_name( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> DeleteResponse: """ Delete a task by its unique name. @@ -461,7 +461,7 @@ async def retrieve_by_name( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> Task: """ Get a task by its unique name. @@ -494,7 +494,7 @@ async def stream_events( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> AsyncStream[object]: """ Stream events for a task by its unique ID. @@ -529,7 +529,7 @@ async def stream_events_by_name( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> AsyncStream[object]: """ Stream events for a task by its unique name. diff --git a/src/agentex/resources/tracker.py b/src/agentex/resources/tracker.py index 1a74df21..ddaf573a 100644 --- a/src/agentex/resources/tracker.py +++ b/src/agentex/resources/tracker.py @@ -7,7 +7,7 @@ import httpx from ..types import tracker_list_params, tracker_update_params -from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property from .._resource import SyncAPIResource, AsyncAPIResource @@ -53,7 +53,7 @@ def retrieve( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> AgentTaskTracker: """ Get agent task tracker by tracker ID @@ -81,15 +81,15 @@ def update( self, tracker_id: str, *, - last_processed_event_id: Optional[str] | NotGiven = NOT_GIVEN, - status: Optional[str] | NotGiven = NOT_GIVEN, - status_reason: Optional[str] | NotGiven = NOT_GIVEN, + last_processed_event_id: Optional[str] | Omit = omit, + status: Optional[str] | Omit = omit, + status_reason: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> AgentTaskTracker: """ Update agent task tracker by tracker ID @@ -130,14 +130,14 @@ def update( def list( self, *, - agent_id: Optional[str] | NotGiven = NOT_GIVEN, - task_id: Optional[str] | NotGiven = NOT_GIVEN, + agent_id: Optional[str] | Omit = omit, + task_id: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> TrackerListResponse: """ List all agent task trackers, optionally filtered by query parameters. @@ -203,7 +203,7 @@ async def retrieve( extra_headers: Headers | None = None, extra_query: Query | None = None, extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> AgentTaskTracker: """ Get agent task tracker by tracker ID @@ -231,15 +231,15 @@ async def update( self, tracker_id: str, *, - last_processed_event_id: Optional[str] | NotGiven = NOT_GIVEN, - status: Optional[str] | NotGiven = NOT_GIVEN, - status_reason: Optional[str] | NotGiven = NOT_GIVEN, + last_processed_event_id: Optional[str] | Omit = omit, + status: Optional[str] | Omit = omit, + status_reason: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> AgentTaskTracker: """ Update agent task tracker by tracker ID @@ -280,14 +280,14 @@ async def update( async def list( self, *, - agent_id: Optional[str] | NotGiven = NOT_GIVEN, - task_id: Optional[str] | NotGiven = NOT_GIVEN, + agent_id: Optional[str] | Omit = omit, + task_id: Optional[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, + timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> TrackerListResponse: """ List all agent task trackers, optionally filtered by query parameters. diff --git a/tests/test_transform.py b/tests/test_transform.py index 20ef1c66..beafc1b8 100644 --- a/tests/test_transform.py +++ b/tests/test_transform.py @@ -8,7 +8,7 @@ import pytest -from agentex._types import NOT_GIVEN, Base64FileInput +from agentex._types import Base64FileInput, omit, not_given from agentex._utils import ( PropertyInfo, transform as _transform, @@ -450,4 +450,11 @@ async def test_transform_skipping(use_async: bool) -> None: @pytest.mark.asyncio async def test_strips_notgiven(use_async: bool) -> None: assert await transform({"foo_bar": "bar"}, Foo1, use_async) == {"fooBar": "bar"} - assert await transform({"foo_bar": NOT_GIVEN}, Foo1, use_async) == {} + assert await transform({"foo_bar": not_given}, Foo1, use_async) == {} + + +@parametrize +@pytest.mark.asyncio +async def test_strips_omit(use_async: bool) -> None: + assert await transform({"foo_bar": "bar"}, Foo1, use_async) == {"fooBar": "bar"} + assert await transform({"foo_bar": omit}, Foo1, use_async) == {} From 69af9e5cead7b855daae5209baea4a7a7d9bf3af Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Sep 2025 15:25:44 +0000 Subject: [PATCH 0208/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From f3335da08a4d3d4e2efc2271188e971a13574363 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Sep 2025 16:25:37 +0000 Subject: [PATCH 0209/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From c3890004c36d6bfebb4ff93e51b8df67b282a6cf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Sep 2025 18:25:32 +0000 Subject: [PATCH 0210/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 4283e1c40fe24e8ae149bb73bfcb87d9c2f3269e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Sep 2025 19:25:32 +0000 Subject: [PATCH 0211/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 7bcaf11442c6793d4bb83ad55eca9e5801c4916e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Sep 2025 20:25:32 +0000 Subject: [PATCH 0212/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From c7762b96d4bfc297a329080ceb25135ff386be6b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Sep 2025 21:25:40 +0000 Subject: [PATCH 0213/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 5273b4daad2857c9647b46bc62516b20f6a0a945 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Sep 2025 22:25:40 +0000 Subject: [PATCH 0214/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From b68d1098f301b8589d050d451c79e87b3edc750a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Sep 2025 23:25:40 +0000 Subject: [PATCH 0215/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 936155ed5d27f85fa67ef6babb0bbcb20915db23 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 19 Sep 2025 00:25:39 +0000 Subject: [PATCH 0216/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From e6928d38000542f8a5a9270bf9c06a9b2a5d0572 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 19 Sep 2025 02:25:39 +0000 Subject: [PATCH 0217/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 9abe5e57f7ccd921c95a1df2231799db13ad6df6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 19 Sep 2025 03:25:49 +0000 Subject: [PATCH 0218/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 93e690903cb2f42ece1b75ccc07a4a5a4817f9b1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 19 Sep 2025 05:25:40 +0000 Subject: [PATCH 0219/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From bcc13ba65e02491899a1b842ceab806e9e67d9d1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 19 Sep 2025 06:25:39 +0000 Subject: [PATCH 0220/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 22721188536f8a16db900fd22d0ea0e2f336cb63 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 19 Sep 2025 10:25:45 +0000 Subject: [PATCH 0221/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 06c65d06812b165d08acd00693750af7b9f1a36a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 19 Sep 2025 11:25:34 +0000 Subject: [PATCH 0222/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From abc3b84b694a6eeeb690ac53686d0b7d1f8266f8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 19 Sep 2025 12:25:34 +0000 Subject: [PATCH 0223/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 6552942816f9f77381bdbd191be30605a0a8362d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 19 Sep 2025 13:25:36 +0000 Subject: [PATCH 0224/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 663e3d579c11b3d599e991f3f7b13d13efff129c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 19 Sep 2025 14:25:42 +0000 Subject: [PATCH 0225/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 2ee5de3db546481735eaa244bac00919c3db103c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 19 Sep 2025 16:25:43 +0000 Subject: [PATCH 0226/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From b54d8efdcbd959170fdc35f8ac03ea1d1b4d3094 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 19 Sep 2025 17:42:37 +0000 Subject: [PATCH 0227/1108] chore: do not install brew dependencies in ./scripts/bootstrap by default --- scripts/bootstrap | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/scripts/bootstrap b/scripts/bootstrap index e84fe62c..b430fee3 100755 --- a/scripts/bootstrap +++ b/scripts/bootstrap @@ -4,10 +4,18 @@ set -e cd "$(dirname "$0")/.." -if ! command -v rye >/dev/null 2>&1 && [ -f "Brewfile" ] && [ "$(uname -s)" = "Darwin" ]; then +if [ -f "Brewfile" ] && [ "$(uname -s)" = "Darwin" ] && [ "$SKIP_BREW" != "1" ] && [ -t 0 ]; then brew bundle check >/dev/null 2>&1 || { - echo "==> Installing Homebrew dependencies…" - brew bundle + echo -n "==> Install Homebrew dependencies? (y/N): " + read -r response + case "$response" in + [yY][eE][sS]|[yY]) + brew bundle + ;; + *) + ;; + esac + echo } fi From bd6806a07989434fe8da98c53ef1f6d763446fe9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 19 Sep 2025 18:25:45 +0000 Subject: [PATCH 0228/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From d5df4c76b2c392e89b268cecc60e9e60e970d9ab Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 19 Sep 2025 23:25:41 +0000 Subject: [PATCH 0229/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 525f3e6ba797cfc2616b360cb1586e39761555a0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 20 Sep 2025 01:25:41 +0000 Subject: [PATCH 0230/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From a115ada09a03a0a7dead5c62b95f1ee0e84919c9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 20 Sep 2025 02:25:43 +0000 Subject: [PATCH 0231/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 14ce34b59554da5635f8597160ac35e4b0ae1dce Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 20 Sep 2025 03:25:41 +0000 Subject: [PATCH 0232/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 14c2704511edf6c09d0a15ebf6c82f9c594b34cf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 20 Sep 2025 05:25:41 +0000 Subject: [PATCH 0233/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 907e96f0fa3f87ae094a0be4c3694d4d1e89a5c3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 20 Sep 2025 07:25:41 +0000 Subject: [PATCH 0234/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 2d237502afdb7a40b98c4d92fcc68e0d1d4906e8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 20 Sep 2025 09:25:33 +0000 Subject: [PATCH 0235/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 4c173d24f4a51d2a02f1408f219ae287fc05ceb4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 20 Sep 2025 10:25:34 +0000 Subject: [PATCH 0236/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 9cf553445fcd88fc58a518f66ca5c6b324d00b75 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 20 Sep 2025 12:25:35 +0000 Subject: [PATCH 0237/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From ad83d93486d5f4acee893ff0307ccc92bde720c9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 20 Sep 2025 13:25:41 +0000 Subject: [PATCH 0238/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 7fbeda5bdae9ad22c84b6f4768b474616c8d10e1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 20 Sep 2025 18:26:02 +0000 Subject: [PATCH 0239/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From dd6719363d29904c9d28d0beba8de2922e4e5bbb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 20 Sep 2025 19:25:58 +0000 Subject: [PATCH 0240/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From a1817090de10d00a477880eb57fa86242b95ce33 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 20 Sep 2025 23:26:08 +0000 Subject: [PATCH 0241/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From ebb1c2806d893bb661bbd4a99f384fd290d60c68 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 21 Sep 2025 00:26:06 +0000 Subject: [PATCH 0242/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 69545812fa3c604609f779d54f4918b524e5ecff Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 21 Sep 2025 01:26:07 +0000 Subject: [PATCH 0243/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 09d144cd51fd1ece96dcb552ad4075ed7d6b06e3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 21 Sep 2025 02:26:08 +0000 Subject: [PATCH 0244/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 7d8f627bb4d95ee021c56d2d56403f4464b9e8a8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 21 Sep 2025 04:26:07 +0000 Subject: [PATCH 0245/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 6c6a65ed090ab588737ef23f41b06ecf97c0ffc1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 21 Sep 2025 05:26:09 +0000 Subject: [PATCH 0246/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 07e72fa1cb64f0a399e58f8f8fe68a413a2035ce Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 21 Sep 2025 08:26:16 +0000 Subject: [PATCH 0247/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From a86ba1c93aeac362718a683ad927df8efdf0a309 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 21 Sep 2025 09:26:11 +0000 Subject: [PATCH 0248/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 5558668979298f0763efe6ce6afe5cada7748bc4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 21 Sep 2025 12:26:18 +0000 Subject: [PATCH 0249/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 07cf95b763b2e87b875f102f62584a55a9e9656f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 21 Sep 2025 15:26:32 +0000 Subject: [PATCH 0250/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 31060a7c3378720163949abc8510fd9674fbe75a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 21 Sep 2025 17:26:32 +0000 Subject: [PATCH 0251/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 9980b885f93f85543f9ff98fa8780f4d6cdf74a2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 21 Sep 2025 18:14:05 +0000 Subject: [PATCH 0252/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From b0c8981bb80e2b2faa2888feddf2470fdd55f0de Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 21 Sep 2025 19:15:22 +0000 Subject: [PATCH 0253/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 07538017a4bbe28febbbe0ec5570b8807aebc32b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 21 Sep 2025 21:15:20 +0000 Subject: [PATCH 0254/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 0b1a59385af1794427442189d07d91a02be088c5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 21 Sep 2025 22:15:18 +0000 Subject: [PATCH 0255/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 39593937ff451e46e9aa28faf8be103038e2e1c8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 01:15:28 +0000 Subject: [PATCH 0256/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 553c3729264101b0036dc05f9887460d7f3841dd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 03:15:46 +0000 Subject: [PATCH 0257/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 6188280893ba9e3b521adb553b135af5d83cef43 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 06:15:41 +0000 Subject: [PATCH 0258/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From fde79d97d4db75017d22803e61bd9dceb893f41d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 07:24:12 +0000 Subject: [PATCH 0259/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From d8d8587e862c33f511cba8657ba6bc25cdad55d4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 08:24:17 +0000 Subject: [PATCH 0260/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 071b040c8fb7a61300f0b46aa5cedad4da224599 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 10:13:25 +0000 Subject: [PATCH 0261/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From c27b43fae38a5b79b9d82a4718a4fc0ffcdf569a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 13:28:30 +0000 Subject: [PATCH 0262/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 629bf2c96778ed18ab34efafa78719eed550adfa Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 15:07:13 +0000 Subject: [PATCH 0263/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From a7afd139ad89eb5f47fb9375ba609049abb8e479 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 15:47:25 +0000 Subject: [PATCH 0264/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 691df353066b46b1fa748923136084a71cb90053 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 16:32:41 +0000 Subject: [PATCH 0265/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 8c2cfd260c4eada9a1a4ee92fc88724a33b48068 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 16:43:24 +0000 Subject: [PATCH 0266/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 0cd97303638b414215fa7cb5ece369bacd156005 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 18:22:46 +0000 Subject: [PATCH 0267/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From f22040acb3b204c60b2f320ed4d91369db982ab8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 19:23:08 +0000 Subject: [PATCH 0268/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 1d3cfac0f5e7e17e27c2977753aa5f8301998af5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 19:25:40 +0000 Subject: [PATCH 0269/1108] chore: improve example values --- tests/api_resources/messages/test_batch.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/tests/api_resources/messages/test_batch.py b/tests/api_resources/messages/test_batch.py index a572047a..1b25aaab 100644 --- a/tests/api_resources/messages/test_batch.py +++ b/tests/api_resources/messages/test_batch.py @@ -25,6 +25,7 @@ def test_method_create(self, client: Agentex) -> None: { "author": "user", "content": "content", + "type": "text", } ], task_id="task_id", @@ -39,6 +40,7 @@ def test_raw_response_create(self, client: Agentex) -> None: { "author": "user", "content": "content", + "type": "text", } ], task_id="task_id", @@ -57,6 +59,7 @@ def test_streaming_response_create(self, client: Agentex) -> None: { "author": "user", "content": "content", + "type": "text", } ], task_id="task_id", @@ -78,6 +81,7 @@ def test_method_update(self, client: Agentex) -> None: "foo": { "author": "user", "content": "content", + "type": "text", } }, ) @@ -92,6 +96,7 @@ def test_raw_response_update(self, client: Agentex) -> None: "foo": { "author": "user", "content": "content", + "type": "text", } }, ) @@ -110,6 +115,7 @@ def test_streaming_response_update(self, client: Agentex) -> None: "foo": { "author": "user", "content": "content", + "type": "text", } }, ) as response: @@ -135,6 +141,7 @@ async def test_method_create(self, async_client: AsyncAgentex) -> None: { "author": "user", "content": "content", + "type": "text", } ], task_id="task_id", @@ -149,6 +156,7 @@ async def test_raw_response_create(self, async_client: AsyncAgentex) -> None: { "author": "user", "content": "content", + "type": "text", } ], task_id="task_id", @@ -167,6 +175,7 @@ async def test_streaming_response_create(self, async_client: AsyncAgentex) -> No { "author": "user", "content": "content", + "type": "text", } ], task_id="task_id", @@ -188,6 +197,7 @@ async def test_method_update(self, async_client: AsyncAgentex) -> None: "foo": { "author": "user", "content": "content", + "type": "text", } }, ) @@ -202,6 +212,7 @@ async def test_raw_response_update(self, async_client: AsyncAgentex) -> None: "foo": { "author": "user", "content": "content", + "type": "text", } }, ) @@ -220,6 +231,7 @@ async def test_streaming_response_update(self, async_client: AsyncAgentex) -> No "foo": { "author": "user", "content": "content", + "type": "text", } }, ) as response: From d235ba31a1cdde333bf9012f0ff83c4b57bfb42a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 20:22:44 +0000 Subject: [PATCH 0270/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 71c1771e5be53628c591555ffdc7dc8759cf42ed Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 22 Sep 2025 22:22:46 +0000 Subject: [PATCH 0271/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From e265cba65b3f6c115144427faa9e235e61126c27 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 23 Sep 2025 00:22:47 +0000 Subject: [PATCH 0272/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From cda6520071fcd9c98bd59ef99cc3e3e11abe938c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 23 Sep 2025 02:22:48 +0000 Subject: [PATCH 0273/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 00e0716c9a9dba5a97d04eccc9874e8f720d54c1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 23 Sep 2025 03:22:48 +0000 Subject: [PATCH 0274/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 15482805eca067554d79089c156b2f364dcb3fda Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 23 Sep 2025 05:22:47 +0000 Subject: [PATCH 0275/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 39d2141e86a63d25de397efec3bd78857fd424c0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 23 Sep 2025 06:22:47 +0000 Subject: [PATCH 0276/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 2e93eb70827c6eb0985d2ac504a70541d7560b08 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 23 Sep 2025 12:22:46 +0000 Subject: [PATCH 0277/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 32205741e3ed0530de5cafbb88c4ae3c58e90e21 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 23 Sep 2025 13:22:45 +0000 Subject: [PATCH 0278/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 2e7b60f16bb8c37209b5389ce9fc3b7a300341ab Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 23 Sep 2025 15:22:45 +0000 Subject: [PATCH 0279/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 8551cb92d21d47af05247526c2c2ecfa3dd73b8e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 23 Sep 2025 16:22:45 +0000 Subject: [PATCH 0280/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 5bf3e1daa7232cfbcef60e7cc81389d5565322f3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 23 Sep 2025 17:22:44 +0000 Subject: [PATCH 0281/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From c7bee438e7ceb7edb349ede355e0615e666489b0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 23 Sep 2025 18:22:47 +0000 Subject: [PATCH 0282/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From a9bedd332bc81d0b1f6bd5672ee180510faf1a52 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 23 Sep 2025 19:22:47 +0000 Subject: [PATCH 0283/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From ebc8a1c87ff72a786e600a18ff73b3583a9cb2f0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 23 Sep 2025 20:22:47 +0000 Subject: [PATCH 0284/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From dfa4b84aabfd1de1342380ce4389049fcc7359b9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 23 Sep 2025 21:22:45 +0000 Subject: [PATCH 0285/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 0536beba7de7123aa442771bbc556fc2cdac015e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 24 Sep 2025 00:22:47 +0000 Subject: [PATCH 0286/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From d950f8424ea9cf22daa78d99a6d94ac7b5d981be Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 24 Sep 2025 02:22:45 +0000 Subject: [PATCH 0287/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From d8d54d8e724287b50dc0ae62d37515c6e7589545 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 24 Sep 2025 04:22:48 +0000 Subject: [PATCH 0288/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 9bc123800e36f35789adc341c894b7284a069596 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 24 Sep 2025 08:22:44 +0000 Subject: [PATCH 0289/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From ca184bd863e23f261720c2c51e955ee4b870872a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 24 Sep 2025 10:22:59 +0000 Subject: [PATCH 0290/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 4f36eca71014303e7784cd183517b1dfe1d30aa9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 24 Sep 2025 11:22:44 +0000 Subject: [PATCH 0291/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From de50c6b6ad6f7c7fbe69f8a9e31c6eb869840d66 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 24 Sep 2025 12:22:42 +0000 Subject: [PATCH 0292/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 75e2ac8d2c37f9ef71a489e18942d0b42471146c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 24 Sep 2025 15:22:36 +0000 Subject: [PATCH 0293/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From b58a4ec8f738d0be4fe4a8a95718ef5185ba693c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 24 Sep 2025 17:22:38 +0000 Subject: [PATCH 0294/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From cd707a5f43895f4fe13a84a1cc68eb7e925c6503 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 24 Sep 2025 18:22:39 +0000 Subject: [PATCH 0295/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 01de09bb78bb6615d23644f913cf254ee8509832 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 24 Sep 2025 19:22:36 +0000 Subject: [PATCH 0296/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From c4cef815b89c75d3fa03817f564c6b57baeb7193 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 24 Sep 2025 22:22:38 +0000 Subject: [PATCH 0297/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From b60efd53a30f9b8eb9889ff81ea597f8bc66fa6d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 25 Sep 2025 02:22:35 +0000 Subject: [PATCH 0298/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 92c635a80192693204b7275a92c1f65e46aff8d1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 25 Sep 2025 04:22:37 +0000 Subject: [PATCH 0299/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 0fe710dda5b0766076a81f069fcc05ffce5e388a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 25 Sep 2025 05:22:35 +0000 Subject: [PATCH 0300/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 684ad3f56d68f1da66a08f07b6bb076d2a06bb90 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 25 Sep 2025 06:22:38 +0000 Subject: [PATCH 0301/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 2c825a259d91971bd503a58bda381c371c1e928c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 25 Sep 2025 09:22:37 +0000 Subject: [PATCH 0302/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 24e557214906fa0e09bcd6be9c768500d6149515 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 25 Sep 2025 12:22:37 +0000 Subject: [PATCH 0303/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From facd186dc7363de809e30bf4fcf5babef35afb63 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 25 Sep 2025 15:22:37 +0000 Subject: [PATCH 0304/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 96daf0d05d55542764d1cdf8eb84ac10590ab195 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 25 Sep 2025 17:22:38 +0000 Subject: [PATCH 0305/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From d3c0ebf350e9ad9f2bbbbf544d2ad1b123316082 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 25 Sep 2025 19:22:40 +0000 Subject: [PATCH 0306/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 220817d8ce1f4fcde8ce66042f5a5d014679b5cf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 25 Sep 2025 21:22:37 +0000 Subject: [PATCH 0307/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From bcf64d225218894845f0947919c5d4c85baf1a89 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 25 Sep 2025 22:22:40 +0000 Subject: [PATCH 0308/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From ad48eaf02cf6457886a5609261f92ddb1fd5da1e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 25 Sep 2025 23:22:36 +0000 Subject: [PATCH 0309/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 88caed9e11ae046676542d273e596a24af9df554 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 26 Sep 2025 00:22:38 +0000 Subject: [PATCH 0310/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From f9ba8f4254cef57af43b2983a9fb67e41eac7c18 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 26 Sep 2025 03:22:37 +0000 Subject: [PATCH 0311/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 2d5b361d7544629a9f5b1d477d2b59599c138740 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 26 Sep 2025 04:22:43 +0000 Subject: [PATCH 0312/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 265dff0247f9232d7f683a489430d7cb44d69b23 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 26 Sep 2025 05:22:37 +0000 Subject: [PATCH 0313/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From d32c0ab1bf946606588cc621be5ce098a9cccf8a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 26 Sep 2025 07:22:37 +0000 Subject: [PATCH 0314/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 93ceb7a719eaee1f7cb1f74b14ee4afd85d841e3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 26 Sep 2025 09:22:38 +0000 Subject: [PATCH 0315/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 06aaad0e4314febb9dccb0361683b3f9d3020235 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 26 Sep 2025 10:22:38 +0000 Subject: [PATCH 0316/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From a38db849ea18fccaf3fdc630be71a62d36c3bef7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 26 Sep 2025 12:22:37 +0000 Subject: [PATCH 0317/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From a6db8d95b833e143a67e1e68ef0aa110d8a90288 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 26 Sep 2025 13:22:43 +0000 Subject: [PATCH 0318/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 63a8ada3584e1a354f942106c9f943b1c399ca56 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 26 Sep 2025 17:22:41 +0000 Subject: [PATCH 0319/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 0c0d2e06d139a99941018c80e859c43b0d4eecdf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 26 Sep 2025 18:22:54 +0000 Subject: [PATCH 0320/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From da128e2f757cdf8f0f8c28e693cd4ff81db4c45c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 26 Sep 2025 20:22:41 +0000 Subject: [PATCH 0321/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 54e993061927480de08f186ede1efa6d327d1c66 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 29 Sep 2025 14:15:45 +0000 Subject: [PATCH 0322/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 3a5048bc..9ce77a7d 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.16" + ".": "0.4.17" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 4ba5a6c7..fe98d33d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.16" +version = "0.4.17" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 41412071..4b363ffb 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.16" # x-release-please-version +__version__ = "0.4.17" # x-release-please-version From 3130f3fb4c17b467fbc9e17922b4399611a367a8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 29 Sep 2025 19:13:50 +0000 Subject: [PATCH 0323/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 9ce77a7d..9ec42cd2 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.17" + ".": "0.4.18" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index fe98d33d..d5dd1338 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.17" +version = "0.4.18" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 4b363ffb..59c7b8da 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.17" # x-release-please-version +__version__ = "0.4.18" # x-release-please-version From ef43e5959ccec1c431d5a8824ce508be57106c7a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 30 Sep 2025 16:22:51 +0000 Subject: [PATCH 0324/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From bcb1367acd9195582ec7f7b74a8dbc45d4a9ec52 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 30 Sep 2025 17:22:47 +0000 Subject: [PATCH 0325/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 239222af9f88e06d4ff2833fc9225ae001a2b253 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 30 Sep 2025 19:22:47 +0000 Subject: [PATCH 0326/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 9164f54118a545e0ecf4f5b79896eb157418a534 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 1 Oct 2025 16:09:51 +0000 Subject: [PATCH 0327/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 9ec42cd2..d724fefa 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.18" + ".": "0.4.19" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index d5dd1338..26ba94db 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.18" +version = "0.4.19" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 59c7b8da..9c9cc52b 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.18" # x-release-please-version +__version__ = "0.4.19" # x-release-please-version From c469ebf305be39565a440ba03261b1fd963b59d1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 1 Oct 2025 16:23:01 +0000 Subject: [PATCH 0328/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From d3e677726ec0286073786dc6c95fc4a29e8ee69a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 1 Oct 2025 17:23:04 +0000 Subject: [PATCH 0329/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From ebfb0b5563edf5d822ba322e056981eb187bc118 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 1 Oct 2025 18:13:41 +0000 Subject: [PATCH 0330/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index d724fefa..618bac2a 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.19" + ".": "0.4.20" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 26ba94db..177159e6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.19" +version = "0.4.20" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 9c9cc52b..2c03de53 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.19" # x-release-please-version +__version__ = "0.4.20" # x-release-please-version From bef62890496d52e18448e10222a4b1190cc0a8e2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 1 Oct 2025 18:23:02 +0000 Subject: [PATCH 0331/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 710cf3d393be6e48b3834910c9569d975f1fb55f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 1 Oct 2025 18:52:57 +0000 Subject: [PATCH 0332/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 618bac2a..bed1bae0 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.20" + ".": "0.4.21" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 177159e6..e0b780ac 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.20" +version = "0.4.21" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 2c03de53..7b348a98 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.20" # x-release-please-version +__version__ = "0.4.21" # x-release-please-version From aa887748cbfcb3e90e0118ac19084384f860a46d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 1 Oct 2025 19:23:03 +0000 Subject: [PATCH 0333/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 5a6961a2d341a36a582bb72436bc38c225015760 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 1 Oct 2025 20:39:39 +0000 Subject: [PATCH 0334/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index bed1bae0..38ca512a 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.21" + ".": "0.4.22" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index e0b780ac..730774e3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.21" +version = "0.4.22" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 7b348a98..5daf9c5a 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.21" # x-release-please-version +__version__ = "0.4.22" # x-release-please-version From a9f3bdce624da087132b0f7a3f4e4dc2971e0ce9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 1 Oct 2025 23:23:04 +0000 Subject: [PATCH 0335/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 03d5315f4537089b712687e01389adca9d1fc28c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 01:23:05 +0000 Subject: [PATCH 0336/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 8f224e587940191175844dd8edc20981d540724a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 05:23:06 +0000 Subject: [PATCH 0337/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 5bc6529d9c7ccdb4c20cff980744d495fc3d0362 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 06:23:03 +0000 Subject: [PATCH 0338/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 9c5a8e967de0815b02eb3af4d90988bec0a7f446 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 07:23:05 +0000 Subject: [PATCH 0339/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 18534e097733cd8c641d0e4151c4635460c4b64e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 08:23:03 +0000 Subject: [PATCH 0340/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From c720ebf18e1bbdcfe7d77f71ad709f6f949667d5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 09:23:04 +0000 Subject: [PATCH 0341/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From f57ad219fe82c75cb5dc06ce1ef213d866a57baf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 12:23:07 +0000 Subject: [PATCH 0342/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 80c8fb04f28d6070865587386d78950dd98c0cf2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 13:23:06 +0000 Subject: [PATCH 0343/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 21c3f8bef22c7c359b2bada52a943b0dfac1722f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 14:23:39 +0000 Subject: [PATCH 0344/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 04379d0efb93571cf5b34dad9d537692b1c95fe6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 15:23:08 +0000 Subject: [PATCH 0345/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 15853144be1bd04ee97e2dba3a8c394517927f94 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 16:23:07 +0000 Subject: [PATCH 0346/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 0dec2603cf93dc23a10d64c189eff026aa015907 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 17:23:08 +0000 Subject: [PATCH 0347/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 9c422f302dc4df8190441867e1b78866a4432afe Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 18:23:08 +0000 Subject: [PATCH 0348/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From bdeaedf07a55be71b8660e0e2fba5e7afddc8d2c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 22:23:06 +0000 Subject: [PATCH 0349/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From d4c59f04c8aaccc1b7030eabe6b6e32b79f07e53 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 23:13:48 +0000 Subject: [PATCH 0350/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 38ca512a..14d98ddb 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.22" + ".": "0.4.23" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 730774e3..f961d10d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.22" +version = "0.4.23" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 5daf9c5a..7d417228 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.22" # x-release-please-version +__version__ = "0.4.23" # x-release-please-version From a4428c2f66fe5ae35cb84ec919fa33e45605c62d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 3 Oct 2025 00:56:47 +0000 Subject: [PATCH 0351/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 6cce06399d801bd5deaf688c2ae1187f1974f7c9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 3 Oct 2025 02:23:08 +0000 Subject: [PATCH 0352/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 03cfe708686e033783a5253b98e85020884651eb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 3 Oct 2025 04:23:08 +0000 Subject: [PATCH 0353/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From f296bfa881c67f53067e56c3b106294d644e39b6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 3 Oct 2025 06:23:11 +0000 Subject: [PATCH 0354/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From c0b44b92ac2e813c0632d089e190ba310370e740 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 3 Oct 2025 07:23:08 +0000 Subject: [PATCH 0355/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 40551bf1b21ac16c7a6eb0cb25757c2d92899302 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 3 Oct 2025 10:23:25 +0000 Subject: [PATCH 0356/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From f2608c16fba56cf6c22296db22986be6f0f34c52 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 3 Oct 2025 14:23:12 +0000 Subject: [PATCH 0357/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 31130324b80b1ec233dacf963f230d3ac3490981 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 3 Oct 2025 19:23:12 +0000 Subject: [PATCH 0358/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From b1e6c67125b44480feb048c4e4131f9923e34023 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 3 Oct 2025 21:23:11 +0000 Subject: [PATCH 0359/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 92906197265e32e42d4306280c1d2b42fe093d18 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 3 Oct 2025 22:23:08 +0000 Subject: [PATCH 0360/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From b78c4bb04b7091bcd56715a82093a660a2c8e5bb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 3 Oct 2025 23:23:10 +0000 Subject: [PATCH 0361/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 946e2a3c2bc3452af31d96dd343097f32684abf3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 4 Oct 2025 00:23:08 +0000 Subject: [PATCH 0362/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 19ebf8e59bbe363fa113bee663506c3d78239a49 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 4 Oct 2025 01:23:07 +0000 Subject: [PATCH 0363/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From ef463abef0c5379cdc8152735995f0e39e50e388 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 4 Oct 2025 02:23:07 +0000 Subject: [PATCH 0364/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 66e754bd85381b958e882f400d65bbc27d751359 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 4 Oct 2025 04:23:12 +0000 Subject: [PATCH 0365/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 74ba7bd308224a788edfbdd266e3236cfacbaaa6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 4 Oct 2025 06:23:08 +0000 Subject: [PATCH 0366/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From e9b10a8bfcef5a02917e50d257ed17a2d445eaaf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 4 Oct 2025 07:23:12 +0000 Subject: [PATCH 0367/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 9308fb424ef55dc4232dda4b0bd90dfe2cb2fb01 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 4 Oct 2025 08:23:07 +0000 Subject: [PATCH 0368/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From f186c6edbf7730f477d75577e5b61299e6b484f6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 4 Oct 2025 09:23:06 +0000 Subject: [PATCH 0369/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From fb25ed49e7e5ec87f2d4cb5afce2d67a895b3e8e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 4 Oct 2025 11:23:08 +0000 Subject: [PATCH 0370/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 508be53b15f5b2eb56fdf1830be8a77446abce84 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 4 Oct 2025 14:23:06 +0000 Subject: [PATCH 0371/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 193f2c7be4aa4054b717628e2547edf9ddf510ff Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 4 Oct 2025 15:23:07 +0000 Subject: [PATCH 0372/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From be27bfbc54b76f9c759c51d7a59cb11bf23306d0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 4 Oct 2025 17:23:19 +0000 Subject: [PATCH 0373/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 3273c79698109efeae21d808ee13ec4b6ae0e495 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 4 Oct 2025 18:23:09 +0000 Subject: [PATCH 0374/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 3bde68163b7b397aea347fd7734894b5a8133125 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 4 Oct 2025 20:23:12 +0000 Subject: [PATCH 0375/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From b27eddba570b6dd56078e766811dd0101c687aac Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 5 Oct 2025 00:23:12 +0000 Subject: [PATCH 0376/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 6cd3cae66d934e6879b6de11dee014df5694369d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 5 Oct 2025 05:23:09 +0000 Subject: [PATCH 0377/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From a0dad1ff40bf0c9349d56de64b0602bc49f68527 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 5 Oct 2025 06:23:10 +0000 Subject: [PATCH 0378/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 07ad2bac2c4ff7f02ce8bac65c0cd89fa9d1159c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 5 Oct 2025 09:23:12 +0000 Subject: [PATCH 0379/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From c4332cb4fbe4b486e170cd843aaebb5779f9fc90 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 5 Oct 2025 10:23:14 +0000 Subject: [PATCH 0380/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 5a11a5de61fea41d7f6cf8fe333f8b9f81d5fb97 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 5 Oct 2025 11:23:16 +0000 Subject: [PATCH 0381/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From ce0693090fc6a2410f3fb4e33e89f5fe3f78086e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 5 Oct 2025 12:23:17 +0000 Subject: [PATCH 0382/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 711f394b3f20f9f0c577d1d3c725d426f766ff08 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 5 Oct 2025 13:23:10 +0000 Subject: [PATCH 0383/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 45ff2433f19b60de8257bb6ec6cdc099518a2d5b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 5 Oct 2025 14:23:09 +0000 Subject: [PATCH 0384/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From fbd1a5070c893b787ca98643f9b61f08f105fb54 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 5 Oct 2025 15:23:12 +0000 Subject: [PATCH 0385/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 90e6ed8f260173edae795434e77058323baba474 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 5 Oct 2025 16:23:12 +0000 Subject: [PATCH 0386/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 29d975dc18a00830227f0ed7f9cda39c80492ddc Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 5 Oct 2025 19:23:19 +0000 Subject: [PATCH 0387/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From fb50b7326e2c09f321f361e68f385f7904a4b05b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 5 Oct 2025 20:23:11 +0000 Subject: [PATCH 0388/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From e040aab225561a9e0454a1032676c1a058ceb4b0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 5 Oct 2025 23:23:11 +0000 Subject: [PATCH 0389/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From b244fdac3dc834ecfbb75eb5a61a52392517c214 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 00:23:12 +0000 Subject: [PATCH 0390/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 9803bfafaede97050a7376c650b93ddd389788e7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 03:23:21 +0000 Subject: [PATCH 0391/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 2f06d99fe45c45accd9ffc37b5e29d7752f1906c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 05:23:11 +0000 Subject: [PATCH 0392/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 02832cc7df7e01bf592cf5972a0c1cea34368918 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 06:23:10 +0000 Subject: [PATCH 0393/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 688f5098e97e640ac6466e5a106d816d3cf02bb7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 07:23:12 +0000 Subject: [PATCH 0394/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 38a9830722c9c9dc92ccc0d5bad574a1fc19f8b4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 09:23:11 +0000 Subject: [PATCH 0395/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 6441a6150f84d0f2ae3dd514eb30d0ac17d03b6d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 11:23:14 +0000 Subject: [PATCH 0396/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From ce80cf4d1c2b4938d8adc6b74f779b96b89b7697 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 13:23:12 +0000 Subject: [PATCH 0397/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 1913035352cefc565e07c429ae13585c2fb79c98 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 14:23:12 +0000 Subject: [PATCH 0398/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 6fac65de93cb1b344d5edd2cdb0c9827d7bb00b6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 15:23:14 +0000 Subject: [PATCH 0399/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From a48ba954670167306014778a536990dc29ea3c92 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 18:23:13 +0000 Subject: [PATCH 0400/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 620ccc420e0b92425bd925ef949314c78dd9ffad Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 19:23:22 +0000 Subject: [PATCH 0401/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 0b86555cbb5f38db0b2528dc0ffc547668f7cfe6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 20:23:12 +0000 Subject: [PATCH 0402/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From f9465bcd52800ae1c4e4e9cb8928a4ea9d1aab3e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 21:23:13 +0000 Subject: [PATCH 0403/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From b3a929a797b888d925b8992ab6d0bb7c12b73677 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 22:23:11 +0000 Subject: [PATCH 0404/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 8bf63e7d9ee2b6d18e11d1d215ebbf537b69218f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 7 Oct 2025 03:23:09 +0000 Subject: [PATCH 0405/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 1671abe02e65dc43bae543c5d88c635db105e489 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 7 Oct 2025 04:23:09 +0000 Subject: [PATCH 0406/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From de17f14610106af2c14805b17143b7c130e8b4be Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 7 Oct 2025 06:23:10 +0000 Subject: [PATCH 0407/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From dfbb3d340fcfa2c6bcc03e969cf369bc324aa17c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 7 Oct 2025 08:23:10 +0000 Subject: [PATCH 0408/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 8f923013bb016e0339ac825216bc8f26f741c055 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 7 Oct 2025 12:23:18 +0000 Subject: [PATCH 0409/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 7ef99a541e96659606e8bb7afc4b02184c95bb5c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 7 Oct 2025 13:23:11 +0000 Subject: [PATCH 0410/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 1cb1b5c1d2dc6b5eea823b859bdff5b50f2c6092 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 7 Oct 2025 14:23:12 +0000 Subject: [PATCH 0411/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 1fd1dc468dbce12f4e11da5af4353189eaf1df6a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 7 Oct 2025 16:23:10 +0000 Subject: [PATCH 0412/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 2d3837c55a93ae8fe7ef6ba5130196cbab7186d5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 7 Oct 2025 18:23:17 +0000 Subject: [PATCH 0413/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From da1733936d9ff6e5bc7a1b5d5fc4d8aa42d3e959 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 7 Oct 2025 19:23:10 +0000 Subject: [PATCH 0414/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 9f0f999e10893492cbb7cc32ea700fee2eccc6fb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 7 Oct 2025 20:23:10 +0000 Subject: [PATCH 0415/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From d87b6b3a0fa3d03d7efe0ea274aa8167de056f49 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 7 Oct 2025 22:23:12 +0000 Subject: [PATCH 0416/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..eed231f9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml +openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 config_hash: aeabb3a919ad2763f5d0f41961a2520a From f2bd900226446b0210f2a8726d267dbc44092854 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 7 Oct 2025 23:23:10 +0000 Subject: [PATCH 0417/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index eed231f9..db98622c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-80c50e5d150c0baca970fa26bc298a878e02bf5869a16fd3a812255cca077333.yml -openapi_spec_hash: 41bed3c1c935a8054600e6d177faa396 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml +openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d config_hash: aeabb3a919ad2763f5d0f41961a2520a From 2e9c2da0cb718f7823efa7ed97b09316f8d69b6c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 8 Oct 2025 00:23:10 +0000 Subject: [PATCH 0418/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index db98622c..bc6bd212 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-76382de80057321dae48471054ca469af8b5b5b1b0b252e92fd70d7a9998dd6d.yml -openapi_spec_hash: c1e34098e62dee3304ba1d49233e4e9d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 53589bb8c3d97b52c60aaf0ed4432b6c12533b41 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 8 Oct 2025 01:23:09 +0000 Subject: [PATCH 0419/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index bc6bd212..b533ef28 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 7be6dc30e480e5d506fb53676aa6655346cdad6e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 8 Oct 2025 04:23:11 +0000 Subject: [PATCH 0420/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index b533ef28..bc6bd212 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 3054df21f4b7eccb64abfc860ccd4b297738b8a1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 8 Oct 2025 05:23:18 +0000 Subject: [PATCH 0421/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index bc6bd212..b533ef28 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 7acbcff7d34412e26d51fa8486e84692667f2fb1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 8 Oct 2025 06:23:15 +0000 Subject: [PATCH 0422/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index b533ef28..bc6bd212 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: aeabb3a919ad2763f5d0f41961a2520a From c24ce0507caeb6bf9d7df1a826e9c13adeab5fd8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 8 Oct 2025 07:23:23 +0000 Subject: [PATCH 0423/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index bc6bd212..b533ef28 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 1e3e130fb95f6f12410110a83a9db653ef244e0b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 8 Oct 2025 09:23:19 +0000 Subject: [PATCH 0424/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index b533ef28..bc6bd212 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: aeabb3a919ad2763f5d0f41961a2520a From b2e283c8022f71081ec53337b9e72e3c06fd227c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 8 Oct 2025 10:23:22 +0000 Subject: [PATCH 0425/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index bc6bd212..b533ef28 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 1ee9b4b471aeb674517e7a1abe35cabf72794021 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 8 Oct 2025 12:23:18 +0000 Subject: [PATCH 0426/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index b533ef28..bc6bd212 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 137c0c53e6c82b58ce02263acdfabcaffacc57d3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 8 Oct 2025 13:23:19 +0000 Subject: [PATCH 0427/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index bc6bd212..b533ef28 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: aeabb3a919ad2763f5d0f41961a2520a From db9e3d2a1e73f41ed99ba2126d132fe747cb88c0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 8 Oct 2025 14:23:20 +0000 Subject: [PATCH 0428/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index b533ef28..bc6bd212 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: aeabb3a919ad2763f5d0f41961a2520a From 071b265f98814282d1d6d6e314ad9e921e75dd1c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 8 Oct 2025 15:05:23 +0000 Subject: [PATCH 0429/1108] feat(api): manual updates --- .stats.yml | 2 +- README.md | 2 +- SECURITY.md | 4 ++++ pyproject.toml | 2 +- 4 files changed, 7 insertions(+), 3 deletions(-) diff --git a/.stats.yml b/.stats.yml index bc6bd212..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 -config_hash: aeabb3a919ad2763f5d0f41961a2520a +config_hash: 6481ea6b42040f435dedcb00a98f35f8 diff --git a/README.md b/README.md index 45a6c419..e8b874ff 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ It is generated with [Stainless](https://www.stainless.com/). ## Documentation -The full API of this library can be found in [api.md](api.md). +The REST API documentation can be found on [docs.gp.scale.com](https://docs.gp.scale.com). The full API of this library can be found in [api.md](api.md). ## Installation diff --git a/SECURITY.md b/SECURITY.md index d7ff1dab..95eca20a 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -18,6 +18,10 @@ before making any information public. If you encounter security issues that are not directly related to SDKs but pertain to the services or products provided by Agentex, please follow the respective company's security reporting guidelines. +### Agentex Terms and Policies + +Please contact roxanne.farhad@scale.com for any questions or concerns regarding the security of our services. + --- Thank you for helping us keep the SDKs and systems they interact with secure. diff --git a/pyproject.toml b/pyproject.toml index f961d10d..8fb7fe2b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,7 +5,7 @@ description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" authors = [ -{ name = "Agentex", email = "" }, +{ name = "Agentex", email = "roxanne.farhad@scale.com" }, ] dependencies = [ "httpx>=0.23.0, <1", From 238dd81027f9c345e8d286cc91166de6845b31bf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 8 Oct 2025 17:23:19 +0000 Subject: [PATCH 0430/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 1e969216f777d3ea9b4ac6f79d96fc4f9ab1f204 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 8 Oct 2025 19:23:22 +0000 Subject: [PATCH 0431/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 7f555f1c6e4dbebe70fa2303568439f4625496ca Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 8 Oct 2025 23:23:13 +0000 Subject: [PATCH 0432/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From d11c4e3d51d75de44b39b08051ac31dd421cfdf8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 9 Oct 2025 06:23:15 +0000 Subject: [PATCH 0433/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From ccf0e15dfad01aa0b34e56ff9a3a7cea1b5e17c4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 9 Oct 2025 08:23:00 +0000 Subject: [PATCH 0434/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 30d6c21d2e08aea810512e4d4a0f9c9bb187287d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 9 Oct 2025 09:22:59 +0000 Subject: [PATCH 0435/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From aad398ba3c2f30422179f37671fe72d0b5842ad3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 9 Oct 2025 10:23:02 +0000 Subject: [PATCH 0436/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From dea67a491f1ffc5d006b36db899c88e807c238e8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 9 Oct 2025 11:23:12 +0000 Subject: [PATCH 0437/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 2bdce1a23d54672be929166e5c2a3a3b6c1dd6d3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 9 Oct 2025 12:23:13 +0000 Subject: [PATCH 0438/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 8468675c42dcebee28365003aa6048bd667d77be Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 9 Oct 2025 13:23:01 +0000 Subject: [PATCH 0439/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 193d7d7002bdbe95edcc83f6d295d72c54397c54 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 9 Oct 2025 17:23:04 +0000 Subject: [PATCH 0440/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 0105b76203965313f9704bb80a07b2a95efd107d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 9 Oct 2025 19:23:04 +0000 Subject: [PATCH 0441/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 33961724a31671120b6aba896700474b31cd6633 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 9 Oct 2025 21:22:59 +0000 Subject: [PATCH 0442/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From fb6b4a947a57809f0d139c54550316a43bdea642 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 9 Oct 2025 22:22:59 +0000 Subject: [PATCH 0443/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 0f6d5429211e38267d0536a52ea51dc5f56daa6b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 00:23:11 +0000 Subject: [PATCH 0444/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 80be6fc926dbf30a8476f8b6eccf91c371d64e53 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 04:23:04 +0000 Subject: [PATCH 0445/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From ca047c6b117950370195fe5ddb3f706480df44e0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 05:23:09 +0000 Subject: [PATCH 0446/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From b47a3d79276ad36eedca47e53cc411a324d6644a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 06:22:57 +0000 Subject: [PATCH 0447/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From d1f6ce57111966898fbe88960fa36a916f16ee05 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 07:22:57 +0000 Subject: [PATCH 0448/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 8e497cff73cb4a8e54b03142d27b962124073557 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 08:22:56 +0000 Subject: [PATCH 0449/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 949d770b4e942d6cdf43a0762ef4b0a153018f2e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 08:48:18 +0000 Subject: [PATCH 0450/1108] chore(internal): detect missing future annotations with ruff --- pyproject.toml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index 8fb7fe2b..ee9cb148 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -224,6 +224,8 @@ select = [ "B", # remove unused imports "F401", + # check for missing future annotations + "FA102", # bare except statements "E722", # unused arguments @@ -246,6 +248,8 @@ unfixable = [ "T203", ] +extend-safe-fixes = ["FA102"] + [tool.ruff.lint.flake8-tidy-imports.banned-api] "functools.lru_cache".msg = "This function does not retain type information for the wrapped function's arguments; The `lru_cache` function from `_utils` should be used instead" From d9c9476e643d7ad93552519f418bec9cf37d346f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 10:23:11 +0000 Subject: [PATCH 0451/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From d5cddcf210d58a85cf3bdd0191b193f0cce9698f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 12:23:11 +0000 Subject: [PATCH 0452/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 724d1f7d07b9bf99382e084f4d6037641b4fd830 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 13:23:09 +0000 Subject: [PATCH 0453/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 4b787dac64314eee5833f4debcf1dddf78c5452d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 15:06:14 +0000 Subject: [PATCH 0454/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 14d98ddb..9ec1b3eb 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.23" + ".": "0.4.24" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index ee9cb148..1b5084c0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.23" +version = "0.4.24" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 7d417228..316c2cf8 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.23" # x-release-please-version +__version__ = "0.4.24" # x-release-please-version From 4e9872ed3b8c320982b4944ae041a91f1f5d4609 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 18:07:30 +0000 Subject: [PATCH 0455/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 9ec1b3eb..a7d961b3 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.24" + ".": "0.4.25" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 1b5084c0..0f789bee 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.24" +version = "0.4.25" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 316c2cf8..510e8037 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.24" # x-release-please-version +__version__ = "0.4.25" # x-release-please-version From cf424d08af11f8698fca25a4c13a538aa272a906 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 20:23:05 +0000 Subject: [PATCH 0456/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 33b92d786103c58d956aab1f5b580225ebe9b5fc Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 22:23:01 +0000 Subject: [PATCH 0457/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 5d2e68e13b9d5948edec9483c74ba44787e72a2c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 23:22:56 +0000 Subject: [PATCH 0458/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 0e25e3de62ee6fcc0678f5961b9bc3794a6988ba Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 11 Oct 2025 01:22:56 +0000 Subject: [PATCH 0459/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 9ffa433a3eaf04607551df7377885ba8996170d2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 11 Oct 2025 05:23:03 +0000 Subject: [PATCH 0460/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From ca4dd745e255db50d4008a35b5d73f5ba548cf74 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 11 Oct 2025 07:22:58 +0000 Subject: [PATCH 0461/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 724eeb92a7f1bf560b6df8e389280c8c8ea6c426 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 11 Oct 2025 13:23:10 +0000 Subject: [PATCH 0462/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 9a73fe52b45792046c24a37f7665cad9f1fadc11 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 11 Oct 2025 14:22:57 +0000 Subject: [PATCH 0463/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 4403da661d65fd3f32f5c4e4c83f3a9434ecab9c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 11 Oct 2025 17:23:02 +0000 Subject: [PATCH 0464/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 4fa13de8092bdc2281d9c7975d6865c2606ddb65 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 11 Oct 2025 18:23:03 +0000 Subject: [PATCH 0465/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 714e70f8c50cada0e3b9d82558891247bf018453 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 11 Oct 2025 20:22:57 +0000 Subject: [PATCH 0466/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From f0469d2ab29fd66f749ac913384662aa3963b3f8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 12 Oct 2025 00:23:02 +0000 Subject: [PATCH 0467/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 491abd9bb5a0b80da537be4ab407db62cb6bd2ae Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 12 Oct 2025 02:22:57 +0000 Subject: [PATCH 0468/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 14ce68c18d49b53c20bcd9c440743b9732a0b91a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 12 Oct 2025 03:22:56 +0000 Subject: [PATCH 0469/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From fee0b101acbcae87c203de1c02bd73a7958e37d5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 12 Oct 2025 05:23:02 +0000 Subject: [PATCH 0470/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 5fcec9139c0ca56f6a70615853c5f917f29d2d07 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 12 Oct 2025 08:23:03 +0000 Subject: [PATCH 0471/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 3b6026fb4e5f41cd18b4926de9208b1abda70177 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 12 Oct 2025 13:22:57 +0000 Subject: [PATCH 0472/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 3f85d311326829feffedcf1901b5f02135620bbd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 12 Oct 2025 14:22:58 +0000 Subject: [PATCH 0473/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From b5a247ce6be190af748114a7e2ef45d7afec1235 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 12 Oct 2025 18:23:09 +0000 Subject: [PATCH 0474/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 5252ff0d638d0a0380e2db1f2c40f8d9ebeb9cd8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 12 Oct 2025 19:23:00 +0000 Subject: [PATCH 0475/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 6a7345f627842c9a2845634dd79751613094220f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 12 Oct 2025 20:22:51 +0000 Subject: [PATCH 0476/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 50f4bea04aafb753abe02e2a1648cf68cffe711d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 13 Oct 2025 01:22:53 +0000 Subject: [PATCH 0477/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 2321970749db0b88949e6a120e715c8685c62dec Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 13 Oct 2025 02:22:56 +0000 Subject: [PATCH 0478/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 83e87dd2eeab753eef4075d13c52dd9a03d42098 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 13 Oct 2025 03:23:06 +0000 Subject: [PATCH 0479/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From befc5c4a6da7b2fbc4e97a054d8481bc21b1a999 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 13 Oct 2025 04:22:52 +0000 Subject: [PATCH 0480/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 1f968017f4e6d23c2835ac5190c67a0787fc54ec Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 13 Oct 2025 05:22:53 +0000 Subject: [PATCH 0481/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From fff24bf148fb0bc8ed136b04944f3373ec85a138 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 13 Oct 2025 07:22:52 +0000 Subject: [PATCH 0482/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From eb052bea66b35e4cfa158fd80f3ff702b76c1441 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 13 Oct 2025 10:23:01 +0000 Subject: [PATCH 0483/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From cc807cbe9df0fbb77a5b2f9785882e9a2da6e6dd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 13 Oct 2025 13:23:02 +0000 Subject: [PATCH 0484/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 7b1790906526bde4e1e6ef336534cb6b01e85582 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 13 Oct 2025 19:22:53 +0000 Subject: [PATCH 0485/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From b7cdec339ae9fbb1ad051eb16e51e5c9d4aa18d6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 13 Oct 2025 20:22:42 +0000 Subject: [PATCH 0486/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From e74d66f599bf7d35cab3f03877ba3049081ffbae Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 13 Oct 2025 22:22:56 +0000 Subject: [PATCH 0487/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 2a422988dc9084bff27814ac61512d5cff123419 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 14 Oct 2025 01:22:42 +0000 Subject: [PATCH 0488/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 5bd9a67a524943a8e8a1b8a5f77b34b120fe4ec4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 14 Oct 2025 02:22:44 +0000 Subject: [PATCH 0489/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From d5c9198111bfce1778625b8e1a3716508dfbd3dd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 14 Oct 2025 03:22:44 +0000 Subject: [PATCH 0490/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From cc98f2e9c9886d0d6232dd5913e4882e57fcdf5b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 14 Oct 2025 04:22:51 +0000 Subject: [PATCH 0491/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 352d6296c875a55de5dcac5e73d7b0a273519537 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 14 Oct 2025 08:22:44 +0000 Subject: [PATCH 0492/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 6448ec5c8e8755a90caedd07a09824f1f646222a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 14 Oct 2025 09:22:50 +0000 Subject: [PATCH 0493/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From f9d94d14188cb2891cd8ef6c53bd7a9f554f44fa Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 14 Oct 2025 10:22:50 +0000 Subject: [PATCH 0494/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..1f08766a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml +openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From faa7f4666e6edd8c9b0a2c9403c798fcdfedeb2e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 14 Oct 2025 11:22:50 +0000 Subject: [PATCH 0495/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f08766a..36a55644 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-9be75ee61a70a4e4f59426c211157bcad333676bb863f94c2b6fdf8f95629605.yml -openapi_spec_hash: 38a665ae9fb3671e0638d66728f84c77 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml +openapi_spec_hash: cb4a09c023345455749bfc45040951d6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 42253a77a37aeffd8706b4ae448c727d00c699b8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 14 Oct 2025 17:22:45 +0000 Subject: [PATCH 0496/1108] feat(api): api update --- .stats.yml | 4 ++-- src/agentex/types/agent_rpc_by_name_params.py | 6 ++++++ src/agentex/types/agent_rpc_params.py | 6 ++++++ 3 files changed, 14 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 36a55644..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-24426221ca34bef99c2533d049fc93a3b28718229d79339ff4a6f613a4f44ef6.yml -openapi_spec_hash: cb4a09c023345455749bfc45040951d6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 diff --git a/src/agentex/types/agent_rpc_by_name_params.py b/src/agentex/types/agent_rpc_by_name_params.py index b84da84c..ec0f638e 100644 --- a/src/agentex/types/agent_rpc_by_name_params.py +++ b/src/agentex/types/agent_rpc_by_name_params.py @@ -54,6 +54,12 @@ class ParamsSendMessageRequest(TypedDict, total=False): task_id: Optional[str] """The ID of the task that the message was sent to""" + task_name: Optional[str] + """The name of the task that the message was sent to""" + + task_params: Optional[Dict[str, object]] + """The parameters for the task (only used when creating new tasks)""" + class ParamsSendEventRequest(TypedDict, total=False): content: Optional[TaskMessageContentParam] diff --git a/src/agentex/types/agent_rpc_params.py b/src/agentex/types/agent_rpc_params.py index e4ae3ab1..fa101e79 100644 --- a/src/agentex/types/agent_rpc_params.py +++ b/src/agentex/types/agent_rpc_params.py @@ -54,6 +54,12 @@ class ParamsSendMessageRequest(TypedDict, total=False): task_id: Optional[str] """The ID of the task that the message was sent to""" + task_name: Optional[str] + """The name of the task that the message was sent to""" + + task_params: Optional[Dict[str, object]] + """The parameters for the task (only used when creating new tasks)""" + class ParamsSendEventRequest(TypedDict, total=False): content: Optional[TaskMessageContentParam] From db38eab6c0f45bb7d82a99cc27745fb143075eb4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 14 Oct 2025 18:22:45 +0000 Subject: [PATCH 0497/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 6fbbf768b7cf50c3ae6b1b5cf2ed4f6e14ee175b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 14 Oct 2025 20:22:52 +0000 Subject: [PATCH 0498/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 884adf42f47a0931cff6e98a024d69da77b8de38 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 14 Oct 2025 22:22:54 +0000 Subject: [PATCH 0499/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From ac567fa949bf22539611b06f4b94688cd57e0c74 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 15 Oct 2025 02:22:39 +0000 Subject: [PATCH 0500/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From dfd704e83aa5ab94e4cbc3dc43ea3b6db1c8c87c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 15 Oct 2025 03:22:40 +0000 Subject: [PATCH 0501/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 716e37e824456a98d12556100b454f71de7d06c4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 15 Oct 2025 05:22:40 +0000 Subject: [PATCH 0502/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 5fefbd466f505778ee9eba0de80332b26bdd77ae Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 15 Oct 2025 06:22:40 +0000 Subject: [PATCH 0503/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 8b3f6f05379f40535fec3352f5bf0884743280a6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 15 Oct 2025 07:22:46 +0000 Subject: [PATCH 0504/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 19cc1fc7765b7c7934b4275b1e7e4bb81025ad39 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 15 Oct 2025 09:22:40 +0000 Subject: [PATCH 0505/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 81b0899afff69e0c12be50701ffaad2387a68be1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 15 Oct 2025 11:22:47 +0000 Subject: [PATCH 0506/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From cf43b3018a09b45124892ba7da8777b6d544be66 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 15 Oct 2025 12:22:46 +0000 Subject: [PATCH 0507/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 40476b3b8879610d14f4469853349a1fea18ad33 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 15 Oct 2025 13:22:48 +0000 Subject: [PATCH 0508/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 074d0d24d3995adaa090d42d4956726f34c6141a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 15 Oct 2025 14:22:42 +0000 Subject: [PATCH 0509/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From f826024dd336111d891c9e4977267364fc759141 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 15 Oct 2025 16:22:42 +0000 Subject: [PATCH 0510/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 46342b3b0ba354380713eb75f70de692485dbab0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 15 Oct 2025 19:22:44 +0000 Subject: [PATCH 0511/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 8bd6f40bd33c66a71d75e55cfa0d0c24f1012323 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 15 Oct 2025 22:22:48 +0000 Subject: [PATCH 0512/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From dc3d08c42c7164f145e7e7d0d1ce9172f68c90e0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 01:22:50 +0000 Subject: [PATCH 0513/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From cc60e38b7aef32047387de6b8d1c7b7e567454d6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 02:22:48 +0000 Subject: [PATCH 0514/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From fcb36f5f3b2417848893eef3210ab40076161d99 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 05:22:42 +0000 Subject: [PATCH 0515/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From f83356ec036fbbcd6b670dacec098e6e4c5c26e0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 06:22:38 +0000 Subject: [PATCH 0516/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 216ec64526b87b9af0caf503797d07e9181c7475 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 07:22:37 +0000 Subject: [PATCH 0517/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 36bb4b747f280e38d8f4ec56c230451769f1bf2f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 08:22:48 +0000 Subject: [PATCH 0518/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 25490cd5ce461c58f371318a7d7e463e78837542 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 09:22:38 +0000 Subject: [PATCH 0519/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 041550d6861d2afc508e885ec4caaad045cfbdeb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 10:22:40 +0000 Subject: [PATCH 0520/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 8b70903c0ef3f189a97bdd372906d62e64c1ac30 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 11:22:37 +0000 Subject: [PATCH 0521/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 0628c352265f6f054644e20b3590449a96c917af Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 12:22:48 +0000 Subject: [PATCH 0522/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 208e66a5650a8493aec1381755c63ad7211431c8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 15:22:40 +0000 Subject: [PATCH 0523/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From bd63644e3d3ae94e71371f38804636b351ef0fd5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 19:22:37 +0000 Subject: [PATCH 0524/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 2af730a78603f7423d27630a30052bae61d7f412 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 21:22:45 +0000 Subject: [PATCH 0525/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From fa7256e30dd01f907894a7b38ad5bde33b366d7c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 22:22:42 +0000 Subject: [PATCH 0526/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 38779e339e1857d0250d072ddf7a6d8833b9fc86 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 17 Oct 2025 00:22:35 +0000 Subject: [PATCH 0527/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From efdfa2a122487fa69bc84f57af89ff9b0a5c0334 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 17 Oct 2025 01:22:33 +0000 Subject: [PATCH 0528/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From f29a6c746a94727da4748025fee503e612715eef Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 17 Oct 2025 02:22:45 +0000 Subject: [PATCH 0529/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From cd5711fa530a79b80e41262e207459e9a30a60eb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 17 Oct 2025 03:22:38 +0000 Subject: [PATCH 0530/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 6d08e415c4f3d2a4e5034dd5221790680621ce04 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 17 Oct 2025 05:22:32 +0000 Subject: [PATCH 0531/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 3511eb91fa334da2504026b6c0e8272611163b8c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 17 Oct 2025 10:20:07 +0000 Subject: [PATCH 0532/1108] chore: bump `httpx-aiohttp` version to 0.1.9 --- pyproject.toml | 2 +- requirements-dev.lock | 2 +- requirements.lock | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 0f789bee..3e14201c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -39,7 +39,7 @@ Homepage = "https://github.com/scaleapi/agentex-python" Repository = "https://github.com/scaleapi/agentex-python" [project.optional-dependencies] -aiohttp = ["aiohttp", "httpx_aiohttp>=0.1.8"] +aiohttp = ["aiohttp", "httpx_aiohttp>=0.1.9"] [tool.rye] managed = true diff --git a/requirements-dev.lock b/requirements-dev.lock index 0203ae90..dba96731 100644 --- a/requirements-dev.lock +++ b/requirements-dev.lock @@ -56,7 +56,7 @@ httpx==0.28.1 # via agentex-sdk # via httpx-aiohttp # via respx -httpx-aiohttp==0.1.8 +httpx-aiohttp==0.1.9 # via agentex-sdk idna==3.4 # via anyio diff --git a/requirements.lock b/requirements.lock index a78ce137..cac2ae2e 100644 --- a/requirements.lock +++ b/requirements.lock @@ -43,7 +43,7 @@ httpcore==1.0.9 httpx==0.28.1 # via agentex-sdk # via httpx-aiohttp -httpx-aiohttp==0.1.8 +httpx-aiohttp==0.1.9 # via agentex-sdk idna==3.4 # via anyio From f8c635e4c169135de35321eb4330a2e4e62d39b0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 17 Oct 2025 13:22:40 +0000 Subject: [PATCH 0533/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 373f8705d32156bf63e0e91fa1021a928fb7a6f5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 17 Oct 2025 15:22:37 +0000 Subject: [PATCH 0534/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 83798e951f251ae86ddb205a7553ae8460142878 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 17 Oct 2025 16:22:32 +0000 Subject: [PATCH 0535/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 17968f5e2d4be74d7bb23704dd3bb15a027da3e5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 17 Oct 2025 17:22:39 +0000 Subject: [PATCH 0536/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From c5e069907914efb7c2a8aa466f6c8a8c8ac663e7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 17 Oct 2025 21:22:35 +0000 Subject: [PATCH 0537/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 1ebfb4e6fa132132340c1dff0a86ad97f368fccb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 17 Oct 2025 22:22:36 +0000 Subject: [PATCH 0538/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From bfa0b7d5245c65212738a89dee22483e3a3e7bdd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 18 Oct 2025 00:22:37 +0000 Subject: [PATCH 0539/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 9216491d11f2152cd44428be891ef57c882cb3a5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 18 Oct 2025 01:22:38 +0000 Subject: [PATCH 0540/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From efc338a12ede5ef1cd60f990d20b14b3283aac98 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 18 Oct 2025 02:22:36 +0000 Subject: [PATCH 0541/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 302bae7bb5a022d945efb36b650a67a0d8b5e610 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 18 Oct 2025 03:22:48 +0000 Subject: [PATCH 0542/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 8cded1688801fb16ff57a56a062ce9fc004bd93a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 18 Oct 2025 04:22:36 +0000 Subject: [PATCH 0543/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From e9179a4513910618c0a059f034eec0476a31c278 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 18 Oct 2025 05:22:36 +0000 Subject: [PATCH 0544/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From d70b3c695135aacb1ac51319b6f52be728966888 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 18 Oct 2025 08:22:36 +0000 Subject: [PATCH 0545/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From ce2885c586b88240b2d087b53dffb994467f26e3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 18 Oct 2025 10:22:42 +0000 Subject: [PATCH 0546/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 1f93fdd4eadd1e434217e95d53320fd21c3b96e6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 18 Oct 2025 11:22:36 +0000 Subject: [PATCH 0547/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From d01c40963203a4f8d3c732ddf2c3d4e30be3d33c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 18 Oct 2025 12:22:43 +0000 Subject: [PATCH 0548/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 9cbd628cdb1f7c982a6b4a9613b9137778ac3f1d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 18 Oct 2025 15:22:42 +0000 Subject: [PATCH 0549/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 2e1325f20b20b545ef843c47e28b5a4553240da0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 18 Oct 2025 17:22:39 +0000 Subject: [PATCH 0550/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 8410cbc92e2223c675ea0c94957e4f8d16017eec Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 18 Oct 2025 18:22:46 +0000 Subject: [PATCH 0551/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 387a780bf84024f7cfbc0944bb8f645cf0dc66a5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 19 Oct 2025 01:22:50 +0000 Subject: [PATCH 0552/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From b825f965d7a66b60f1684efa06138c453600a15a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 19 Oct 2025 02:22:39 +0000 Subject: [PATCH 0553/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 69b243b41e1437f6a7dbd5643dd603d9b4b97a22 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 19 Oct 2025 04:22:52 +0000 Subject: [PATCH 0554/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 5f471766e13c78ec4e557241f5bf93d278252818 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 19 Oct 2025 07:22:50 +0000 Subject: [PATCH 0555/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From e2594a24b0362964f3a4ea27e5ac147d6c8746a9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 19 Oct 2025 08:22:38 +0000 Subject: [PATCH 0556/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 0ca5855e0dd252e78f5e4e2ba8a2e12abdf74939 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 19 Oct 2025 12:22:45 +0000 Subject: [PATCH 0557/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 2e23d08aee67cff4d70459dc9f593179c6e78478 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 19 Oct 2025 17:22:40 +0000 Subject: [PATCH 0558/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From e99201127b696567c556bed9b1cd65c8b0588fe6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 19 Oct 2025 18:22:40 +0000 Subject: [PATCH 0559/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From d0f0ff7d3d8b88e5e97d32b2128e37c01e934dd4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 19 Oct 2025 20:22:51 +0000 Subject: [PATCH 0560/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From cf87dc1610531cf2f8f00400898fa4ebc82dc68a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 19 Oct 2025 21:22:46 +0000 Subject: [PATCH 0561/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From bd51213c9290cfa9c6b1379c0b3dfde4f6326233 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 19 Oct 2025 22:22:39 +0000 Subject: [PATCH 0562/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 690c5881374f9e3644df3214072ec4bb5f58db9c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 19 Oct 2025 23:22:39 +0000 Subject: [PATCH 0563/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 37c71b0a5121fd619259cd4755463edff114c698 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 20 Oct 2025 00:22:38 +0000 Subject: [PATCH 0564/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From beaa1e722ef4f255dfeca684e61162760473fa47 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 20 Oct 2025 02:22:43 +0000 Subject: [PATCH 0565/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 55f07f7c1ad06a3f45305c0f3d8934c27d6049ff Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 20 Oct 2025 05:22:39 +0000 Subject: [PATCH 0566/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 7672cab6b5450a4e401090cc030d248d78df1c0e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 20 Oct 2025 06:22:39 +0000 Subject: [PATCH 0567/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 2c1474579efd05ede99bcb522038e6c79de53674 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 20 Oct 2025 08:22:52 +0000 Subject: [PATCH 0568/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From bc64835c84d7ee04fa5b419444b4735f8af02631 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 20 Oct 2025 12:22:39 +0000 Subject: [PATCH 0569/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From a6eb7ad7c2c9d26bd6fb7c459c90d00fd4415e5a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 20 Oct 2025 15:22:46 +0000 Subject: [PATCH 0570/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From c178ac39c69f5ddf80b7240e18cd577b46bcdcce Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 20 Oct 2025 16:22:39 +0000 Subject: [PATCH 0571/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 3000b01da3780a0773dbfe957138cd038072d7eb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 20 Oct 2025 17:22:50 +0000 Subject: [PATCH 0572/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 25f955355f838b4a165f3635d073abee7847e088 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 20 Oct 2025 20:22:41 +0000 Subject: [PATCH 0573/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 5c7673388c92417b4e9425e5509d3f5c12ca7b9a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 20 Oct 2025 23:22:44 +0000 Subject: [PATCH 0574/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From cf2f26ba0d292a709e48da4ce92ccf450067f39a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 21 Oct 2025 02:22:42 +0000 Subject: [PATCH 0575/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 5ff173a442a3fca8ff3150f9b8aa1528f67ec096 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 21 Oct 2025 03:22:49 +0000 Subject: [PATCH 0576/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 695d00031aea93363169356b493713458ea71acc Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 21 Oct 2025 05:22:42 +0000 Subject: [PATCH 0577/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 232e22b1a1a3392205c83ccc377ae954f17b541b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 21 Oct 2025 07:22:54 +0000 Subject: [PATCH 0578/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 121ecb5b8dfcb000c27852ca6970d6612311701f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 21 Oct 2025 09:22:42 +0000 Subject: [PATCH 0579/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 1644ee9c950ffe7e149ee7646866c15d12b5e416 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 21 Oct 2025 12:22:43 +0000 Subject: [PATCH 0580/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 27e1985da0d4d3f7c28e3394a54dc4ef3bd3bb80 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 21 Oct 2025 15:22:49 +0000 Subject: [PATCH 0581/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..6aac067b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml +openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 41b0ff453628a138ff4a302f88022e20b8b20263 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 21 Oct 2025 16:22:43 +0000 Subject: [PATCH 0582/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6aac067b..5253e364 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-1df9b80a47100ee8c582bdf0301d32a1ce69de186869a1d1ad72a23d087824ba.yml -openapi_spec_hash: cfc41e019e789b7afef49b1ed41da15d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml +openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 2a600ed99e370e725017773f0968a89b9a53e964 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 21 Oct 2025 18:22:57 +0000 Subject: [PATCH 0583/1108] feat(api): api update --- .stats.yml | 4 ++-- src/agentex/types/agent.py | 2 +- src/agentex/types/task.py | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5253e364..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-acd4964141cd927e96d16bc9c7da30082aa4abab3489e21824bb96732ae31b32.yml -openapi_spec_hash: 0576503fa5b2972d6c43981bcb494010 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 diff --git a/src/agentex/types/agent.py b/src/agentex/types/agent.py index 8dfcac0c..731332ab 100644 --- a/src/agentex/types/agent.py +++ b/src/agentex/types/agent.py @@ -35,7 +35,7 @@ class Agent(BaseModel): registration_metadata: Optional[Dict[str, object]] = None """The metadata for the agent's registration.""" - status: Optional[Literal["Pending", "Building", "Ready", "Failed", "Unknown"]] = None + status: Optional[Literal["Ready", "Failed", "Unknown", "Deleted"]] = None """The status of the action, indicating if it's building, ready, failed, etc.""" status_reason: Optional[str] = None diff --git a/src/agentex/types/task.py b/src/agentex/types/task.py index 3b22f819..8b9cde47 100644 --- a/src/agentex/types/task.py +++ b/src/agentex/types/task.py @@ -18,7 +18,7 @@ class Task(BaseModel): params: Optional[Dict[str, object]] = None - status: Optional[Literal["CANCELED", "COMPLETED", "FAILED", "RUNNING", "TERMINATED", "TIMED_OUT"]] = None + status: Optional[Literal["CANCELED", "COMPLETED", "FAILED", "RUNNING", "TERMINATED", "TIMED_OUT", "DELETED"]] = None status_reason: Optional[str] = None From 6a411ad7081414dda22ee0c1a3dab80eaff01dc8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 22 Oct 2025 01:14:31 +0000 Subject: [PATCH 0584/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index a7d961b3..8d63a17d 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.25" + ".": "0.4.26" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 3e14201c..f4e58cd1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.25" +version = "0.4.26" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 510e8037..0b1244ab 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.25" # x-release-please-version +__version__ = "0.4.26" # x-release-please-version From 9ff481c650620f8d93999f30b79cd5cf64a84095 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 23 Oct 2025 23:22:50 +0000 Subject: [PATCH 0585/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From e311ee4f610defde58c193b4fa5222c1f79e00a7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 24 Oct 2025 04:22:46 +0000 Subject: [PATCH 0586/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 9e991adef261e3bb52e6984bdecec6493bfb2973 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 24 Oct 2025 05:22:45 +0000 Subject: [PATCH 0587/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From cfbe2a2bdf8028ccad199b5cb05c9dfb8e03d4ae Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 24 Oct 2025 06:22:45 +0000 Subject: [PATCH 0588/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 834298d01affa9314d1e81228d16c2231c5e8ba7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 24 Oct 2025 08:22:42 +0000 Subject: [PATCH 0589/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From c880370f47c1a979c32633809a50a56f876cecc7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 24 Oct 2025 12:22:38 +0000 Subject: [PATCH 0590/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 667c89fc6f73f8e28c338193d7bb0a47169e0dc5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 24 Oct 2025 13:22:37 +0000 Subject: [PATCH 0591/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 4bbe5541b2cb50a6c08cb62d57277dc28b04bb15 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 24 Oct 2025 14:22:38 +0000 Subject: [PATCH 0592/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 04598d35048b51600f628d55416b385b9d441d48 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 24 Oct 2025 15:22:47 +0000 Subject: [PATCH 0593/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From ddbe89c47835a7ae75cee81a36fc17d804693a72 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 24 Oct 2025 16:22:40 +0000 Subject: [PATCH 0594/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From dd2ca88a1317ce53338bd2542a79bff815f6862d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 24 Oct 2025 17:22:38 +0000 Subject: [PATCH 0595/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 2eca906755819da851171fca578f40a00c486fb9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 26 Oct 2025 02:22:35 +0000 Subject: [PATCH 0596/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 8552e25cb903c2e6fd79d428d659b37e87bbe534 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 26 Oct 2025 04:22:35 +0000 Subject: [PATCH 0597/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 8e873a9b759acd5d3c51ee4b8100e2de69559485 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 26 Oct 2025 07:22:35 +0000 Subject: [PATCH 0598/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From c39763399e1715e4cbde1785033ff19a31ff85ce Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 26 Oct 2025 08:22:35 +0000 Subject: [PATCH 0599/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From d1bb9222e231c23885ddb554f9cdb3e2f4d50d42 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 26 Oct 2025 11:22:35 +0000 Subject: [PATCH 0600/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 03eff5fdad7814d6ced5b0b1c036e4eaa9cc0970 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 26 Oct 2025 12:22:35 +0000 Subject: [PATCH 0601/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From fbe24c35dc76e0601529ca4e63caea3d383861b5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 26 Oct 2025 13:22:35 +0000 Subject: [PATCH 0602/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From c4ddd206d072597334245fc7cc68770370150557 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 26 Oct 2025 15:22:34 +0000 Subject: [PATCH 0603/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 79228f3aebcb940fabf43132ddda88507a654fbf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 26 Oct 2025 17:22:35 +0000 Subject: [PATCH 0604/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 518f7ba3559db48a6483415fc4b1cc5333f5966a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 26 Oct 2025 18:22:36 +0000 Subject: [PATCH 0605/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From d7edab77a8acf70c0835221fece1c0b72a80c22c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 26 Oct 2025 19:22:39 +0000 Subject: [PATCH 0606/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From a267335d3d21dd547c9856fe285b25fdde4c9dac Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 26 Oct 2025 21:22:35 +0000 Subject: [PATCH 0607/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From a7be879f609a57ce5e91239c87ca23cbd8be8112 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 26 Oct 2025 22:22:34 +0000 Subject: [PATCH 0608/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 656140e1729d91c7abdde2ee31d37c34388d7e88 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 27 Oct 2025 04:22:37 +0000 Subject: [PATCH 0609/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 11dc912251875520b44bb0b23b63f05b792daa3e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 27 Oct 2025 05:22:34 +0000 Subject: [PATCH 0610/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From d56b1c7c8bed6e41662eea65f91991bb5533e34b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 27 Oct 2025 06:22:35 +0000 Subject: [PATCH 0611/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From b20210b1f1ffd74715ca5cab998ba493f28c7d39 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 27 Oct 2025 07:22:32 +0000 Subject: [PATCH 0612/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From f742ea03058d791705627d8ee21881c0538a5819 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 27 Oct 2025 08:22:31 +0000 Subject: [PATCH 0613/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From be482821b5babb9f3ee0faa141425441994e5336 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 27 Oct 2025 09:22:34 +0000 Subject: [PATCH 0614/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From d2e9b00e29cce1e1a289ce481bc2a2b2a97a477b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 27 Oct 2025 11:22:39 +0000 Subject: [PATCH 0615/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 1d8d9aa305f4e79dbeb2bc3afdd53fa8b38cbd5b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 27 Oct 2025 13:22:29 +0000 Subject: [PATCH 0616/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..a4548297 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From dcbccef521d20967e11fae51ca19bd8582a7a072 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 27 Oct 2025 17:22:40 +0000 Subject: [PATCH 0617/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index a4548297..cc574bd2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 6481ea6b42040f435dedcb00a98f35f8 From fa8f71d1455dff80e38f14f0f4b760db45759e87 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 27 Oct 2025 19:22:33 +0000 Subject: [PATCH 0618/1108] feat(api): api update --- .stats.yml | 4 +-- src/agentex/resources/agents.py | 30 ++++++++++++++++++++-- src/agentex/resources/messages/messages.py | 8 ++++-- src/agentex/resources/spans.py | 22 ++++++++++++++-- src/agentex/resources/states.py | 16 ++++++++++++ src/agentex/resources/tasks.py | 8 ++++++ src/agentex/resources/tracker.py | 16 ++++++++++++ src/agentex/types/agent_list_params.py | 6 +++++ src/agentex/types/message_list_params.py | 5 ++-- src/agentex/types/span_list_params.py | 4 +++ src/agentex/types/state_list_params.py | 6 +++++ src/agentex/types/task_list_params.py | 4 +++ src/agentex/types/tracker_list_params.py | 6 +++++ tests/api_resources/test_agents.py | 4 +++ tests/api_resources/test_messages.py | 2 ++ tests/api_resources/test_spans.py | 4 +++ tests/api_resources/test_states.py | 4 +++ tests/api_resources/test_tasks.py | 4 +++ tests/api_resources/test_tracker.py | 4 +++ 19 files changed, 147 insertions(+), 10 deletions(-) diff --git a/.stats.yml b/.stats.yml index cc574bd2..9b68d1bc 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6803f43832a4ba37348dfc1daefe5f60f2472b76c73c286257ca370248d64e75.yml +openapi_spec_hash: 44d9bed4803ac9f98419df9e0ad1c485 config_hash: 6481ea6b42040f435dedcb00a98f35f8 diff --git a/src/agentex/resources/agents.py b/src/agentex/resources/agents.py index e59abae2..71297bb7 100644 --- a/src/agentex/resources/agents.py +++ b/src/agentex/resources/agents.py @@ -83,6 +83,8 @@ def retrieve( def list( self, *, + limit: int | Omit = omit, + page_number: int | Omit = omit, task_id: Optional[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. @@ -95,6 +97,10 @@ def list( List all registered agents, optionally filtered by query parameters. Args: + limit: Limit + + page_number: Page number + task_id: Task ID extra_headers: Send extra headers @@ -112,7 +118,14 @@ def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=maybe_transform({"task_id": task_id}, agent_list_params.AgentListParams), + query=maybe_transform( + { + "limit": limit, + "page_number": page_number, + "task_id": task_id, + }, + agent_list_params.AgentListParams, + ), ), cast_to=AgentListResponse, ) @@ -369,6 +382,8 @@ async def retrieve( async def list( self, *, + limit: int | Omit = omit, + page_number: int | Omit = omit, task_id: Optional[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. @@ -381,6 +396,10 @@ async def list( List all registered agents, optionally filtered by query parameters. Args: + limit: Limit + + page_number: Page number + task_id: Task ID extra_headers: Send extra headers @@ -398,7 +417,14 @@ async def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=await async_maybe_transform({"task_id": task_id}, agent_list_params.AgentListParams), + query=await async_maybe_transform( + { + "limit": limit, + "page_number": page_number, + "task_id": task_id, + }, + agent_list_params.AgentListParams, + ), ), cast_to=AgentListResponse, ) diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index a3b856d9..08ebbbd1 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -180,7 +180,8 @@ def list( self, *, task_id: str, - limit: Optional[int] | Omit = omit, + limit: int | Omit = omit, + page_number: int | 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, @@ -213,6 +214,7 @@ def list( { "task_id": task_id, "limit": limit, + "page_number": page_number, }, message_list_params.MessageListParams, ), @@ -367,7 +369,8 @@ async def list( self, *, task_id: str, - limit: Optional[int] | Omit = omit, + limit: int | Omit = omit, + page_number: int | 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, @@ -400,6 +403,7 @@ async def list( { "task_id": task_id, "limit": limit, + "page_number": page_number, }, message_list_params.MessageListParams, ), diff --git a/src/agentex/resources/spans.py b/src/agentex/resources/spans.py index d88ed9e7..b896c74a 100644 --- a/src/agentex/resources/spans.py +++ b/src/agentex/resources/spans.py @@ -222,6 +222,8 @@ def update( def list( self, *, + limit: int | Omit = omit, + page_number: int | Omit = omit, trace_id: Optional[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. @@ -249,7 +251,14 @@ def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=maybe_transform({"trace_id": trace_id}, span_list_params.SpanListParams), + query=maybe_transform( + { + "limit": limit, + "page_number": page_number, + "trace_id": trace_id, + }, + span_list_params.SpanListParams, + ), ), cast_to=SpanListResponse, ) @@ -452,6 +461,8 @@ async def update( async def list( self, *, + limit: int | Omit = omit, + page_number: int | Omit = omit, trace_id: Optional[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. @@ -479,7 +490,14 @@ async def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=await async_maybe_transform({"trace_id": trace_id}, span_list_params.SpanListParams), + query=await async_maybe_transform( + { + "limit": limit, + "page_number": page_number, + "trace_id": trace_id, + }, + span_list_params.SpanListParams, + ), ), cast_to=SpanListResponse, ) diff --git a/src/agentex/resources/states.py b/src/agentex/resources/states.py index 3100adba..d98c2ddc 100644 --- a/src/agentex/resources/states.py +++ b/src/agentex/resources/states.py @@ -166,6 +166,8 @@ def list( self, *, agent_id: Optional[str] | Omit = omit, + limit: int | Omit = omit, + page_number: int | Omit = omit, task_id: Optional[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. @@ -180,6 +182,10 @@ def list( Args: agent_id: Agent ID + limit: Limit + + page_number: Page number + task_id: Task ID extra_headers: Send extra headers @@ -200,6 +206,8 @@ def list( query=maybe_transform( { "agent_id": agent_id, + "limit": limit, + "page_number": page_number, "task_id": task_id, }, state_list_params.StateListParams, @@ -384,6 +392,8 @@ async def list( self, *, agent_id: Optional[str] | Omit = omit, + limit: int | Omit = omit, + page_number: int | Omit = omit, task_id: Optional[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. @@ -398,6 +408,10 @@ async def list( Args: agent_id: Agent ID + limit: Limit + + page_number: Page number + task_id: Task ID extra_headers: Send extra headers @@ -418,6 +432,8 @@ async def list( query=await async_maybe_transform( { "agent_id": agent_id, + "limit": limit, + "page_number": page_number, "task_id": task_id, }, state_list_params.StateListParams, diff --git a/src/agentex/resources/tasks.py b/src/agentex/resources/tasks.py index 0a12e8c3..5d0547cd 100644 --- a/src/agentex/resources/tasks.py +++ b/src/agentex/resources/tasks.py @@ -84,6 +84,8 @@ def list( *, agent_id: Optional[str] | Omit = omit, agent_name: Optional[str] | Omit = omit, + limit: int | Omit = omit, + page_number: int | 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, @@ -114,6 +116,8 @@ def list( { "agent_id": agent_id, "agent_name": agent_name, + "limit": limit, + "page_number": page_number, }, task_list_params.TaskListParams, ), @@ -349,6 +353,8 @@ async def list( *, agent_id: Optional[str] | Omit = omit, agent_name: Optional[str] | Omit = omit, + limit: int | Omit = omit, + page_number: int | 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, @@ -379,6 +385,8 @@ async def list( { "agent_id": agent_id, "agent_name": agent_name, + "limit": limit, + "page_number": page_number, }, task_list_params.TaskListParams, ), diff --git a/src/agentex/resources/tracker.py b/src/agentex/resources/tracker.py index ddaf573a..11bec36f 100644 --- a/src/agentex/resources/tracker.py +++ b/src/agentex/resources/tracker.py @@ -131,6 +131,8 @@ def list( self, *, agent_id: Optional[str] | Omit = omit, + limit: int | Omit = omit, + page_number: int | Omit = omit, task_id: Optional[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. @@ -145,6 +147,10 @@ def list( Args: agent_id: Agent ID + limit: Limit + + page_number: Page number + task_id: Task ID extra_headers: Send extra headers @@ -165,6 +171,8 @@ def list( query=maybe_transform( { "agent_id": agent_id, + "limit": limit, + "page_number": page_number, "task_id": task_id, }, tracker_list_params.TrackerListParams, @@ -281,6 +289,8 @@ async def list( self, *, agent_id: Optional[str] | Omit = omit, + limit: int | Omit = omit, + page_number: int | Omit = omit, task_id: Optional[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. @@ -295,6 +305,10 @@ async def list( Args: agent_id: Agent ID + limit: Limit + + page_number: Page number + task_id: Task ID extra_headers: Send extra headers @@ -315,6 +329,8 @@ async def list( query=await async_maybe_transform( { "agent_id": agent_id, + "limit": limit, + "page_number": page_number, "task_id": task_id, }, tracker_list_params.TrackerListParams, diff --git a/src/agentex/types/agent_list_params.py b/src/agentex/types/agent_list_params.py index b432174a..a724de35 100644 --- a/src/agentex/types/agent_list_params.py +++ b/src/agentex/types/agent_list_params.py @@ -9,5 +9,11 @@ class AgentListParams(TypedDict, total=False): + limit: int + """Limit""" + + page_number: int + """Page number""" + task_id: Optional[str] """Task ID""" diff --git a/src/agentex/types/message_list_params.py b/src/agentex/types/message_list_params.py index 4911bfa9..977972e3 100644 --- a/src/agentex/types/message_list_params.py +++ b/src/agentex/types/message_list_params.py @@ -2,7 +2,6 @@ from __future__ import annotations -from typing import Optional from typing_extensions import Required, TypedDict __all__ = ["MessageListParams"] @@ -12,4 +11,6 @@ class MessageListParams(TypedDict, total=False): task_id: Required[str] """The task ID""" - limit: Optional[int] + limit: int + + page_number: int diff --git a/src/agentex/types/span_list_params.py b/src/agentex/types/span_list_params.py index 35218965..fc9280b0 100644 --- a/src/agentex/types/span_list_params.py +++ b/src/agentex/types/span_list_params.py @@ -9,4 +9,8 @@ class SpanListParams(TypedDict, total=False): + limit: int + + page_number: int + trace_id: Optional[str] diff --git a/src/agentex/types/state_list_params.py b/src/agentex/types/state_list_params.py index 6034d345..9a52c152 100644 --- a/src/agentex/types/state_list_params.py +++ b/src/agentex/types/state_list_params.py @@ -12,5 +12,11 @@ class StateListParams(TypedDict, total=False): agent_id: Optional[str] """Agent ID""" + limit: int + """Limit""" + + page_number: int + """Page number""" + task_id: Optional[str] """Task ID""" diff --git a/src/agentex/types/task_list_params.py b/src/agentex/types/task_list_params.py index f8bc3364..94be17f9 100644 --- a/src/agentex/types/task_list_params.py +++ b/src/agentex/types/task_list_params.py @@ -12,3 +12,7 @@ class TaskListParams(TypedDict, total=False): agent_id: Optional[str] agent_name: Optional[str] + + limit: int + + page_number: int diff --git a/src/agentex/types/tracker_list_params.py b/src/agentex/types/tracker_list_params.py index 47b4da7b..e90dbbb4 100644 --- a/src/agentex/types/tracker_list_params.py +++ b/src/agentex/types/tracker_list_params.py @@ -12,5 +12,11 @@ class TrackerListParams(TypedDict, total=False): agent_id: Optional[str] """Agent ID""" + limit: int + """Limit""" + + page_number: int + """Page number""" + task_id: Optional[str] """Task ID""" diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index 7ef11072..c99d653b 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -74,6 +74,8 @@ def test_method_list(self, client: Agentex) -> None: @parametrize def test_method_list_with_all_params(self, client: Agentex) -> None: agent = client.agents.list( + limit=1, + page_number=1, task_id="task_id", ) assert_matches_type(AgentListResponse, agent, path=["response"]) @@ -414,6 +416,8 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: @parametrize async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.list( + limit=1, + page_number=1, task_id="task_id", ) assert_matches_type(AgentListResponse, agent, path=["response"]) diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py index 457d3e24..f8d83bc2 100644 --- a/tests/api_resources/test_messages.py +++ b/tests/api_resources/test_messages.py @@ -240,6 +240,7 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: message = client.messages.list( task_id="task_id", limit=0, + page_number=0, ) assert_matches_type(MessageListResponse, message, path=["response"]) @@ -495,6 +496,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> message = await async_client.messages.list( task_id="task_id", limit=0, + page_number=0, ) assert_matches_type(MessageListResponse, message, path=["response"]) diff --git a/tests/api_resources/test_spans.py b/tests/api_resources/test_spans.py index b9c9b168..0fb99b51 100644 --- a/tests/api_resources/test_spans.py +++ b/tests/api_resources/test_spans.py @@ -184,6 +184,8 @@ def test_method_list(self, client: Agentex) -> None: @parametrize def test_method_list_with_all_params(self, client: Agentex) -> None: span = client.spans.list( + limit=0, + page_number=0, trace_id="trace_id", ) assert_matches_type(SpanListResponse, span, path=["response"]) @@ -382,6 +384,8 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: @parametrize async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.list( + limit=0, + page_number=0, trace_id="trace_id", ) assert_matches_type(SpanListResponse, span, path=["response"]) diff --git a/tests/api_resources/test_states.py b/tests/api_resources/test_states.py index b23ff49a..e5b74172 100644 --- a/tests/api_resources/test_states.py +++ b/tests/api_resources/test_states.py @@ -164,6 +164,8 @@ def test_method_list(self, client: Agentex) -> None: def test_method_list_with_all_params(self, client: Agentex) -> None: state = client.states.list( agent_id="agent_id", + limit=1, + page_number=1, task_id="task_id", ) assert_matches_type(StateListResponse, state, path=["response"]) @@ -385,6 +387,8 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: state = await async_client.states.list( agent_id="agent_id", + limit=1, + page_number=1, task_id="task_id", ) assert_matches_type(StateListResponse, state, path=["response"]) diff --git a/tests/api_resources/test_tasks.py b/tests/api_resources/test_tasks.py index ac858a80..66e850cc 100644 --- a/tests/api_resources/test_tasks.py +++ b/tests/api_resources/test_tasks.py @@ -72,6 +72,8 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: task = client.tasks.list( agent_id="agent_id", agent_name="agent_name", + limit=0, + page_number=0, ) assert_matches_type(TaskListResponse, task, path=["response"]) @@ -365,6 +367,8 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> task = await async_client.tasks.list( agent_id="agent_id", agent_name="agent_name", + limit=0, + page_number=0, ) assert_matches_type(TaskListResponse, task, path=["response"]) diff --git a/tests/api_resources/test_tracker.py b/tests/api_resources/test_tracker.py index 431508c3..04a6c9d6 100644 --- a/tests/api_resources/test_tracker.py +++ b/tests/api_resources/test_tracker.py @@ -123,6 +123,8 @@ def test_method_list(self, client: Agentex) -> None: def test_method_list_with_all_params(self, client: Agentex) -> None: tracker = client.tracker.list( agent_id="agent_id", + limit=1, + page_number=1, task_id="task_id", ) assert_matches_type(TrackerListResponse, tracker, path=["response"]) @@ -261,6 +263,8 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: tracker = await async_client.tracker.list( agent_id="agent_id", + limit=1, + page_number=1, task_id="task_id", ) assert_matches_type(TrackerListResponse, tracker, path=["response"]) From de4fcb8c550003b6500d3b5d76835abdabd95ab3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 27 Oct 2025 22:25:28 +0000 Subject: [PATCH 0619/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 8d63a17d..170d70a9 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.26" + ".": "0.4.27" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index f4e58cd1..36a3b78a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.26" +version = "0.4.27" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 0b1244ab..8c2cf0d1 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.26" # x-release-please-version +__version__ = "0.4.27" # x-release-please-version From 13c68b9ee84157bba060ff591119350f4194534a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 01:22:46 +0000 Subject: [PATCH 0620/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9b68d1bc..b1572bf4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6803f43832a4ba37348dfc1daefe5f60f2472b76c73c286257ca370248d64e75.yml -openapi_spec_hash: 44d9bed4803ac9f98419df9e0ad1c485 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6dbb005f57f2e54c00322ee75bae1e595160adf1f4eff3b5a8ac38cdeb48fbd6.yml +openapi_spec_hash: 8d36892345fa74be42d2fb10b1d19ab6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 7b3f534b5c0128abc3d2c11b4406c3ced281230d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 02:22:34 +0000 Subject: [PATCH 0621/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index b1572bf4..9b68d1bc 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6dbb005f57f2e54c00322ee75bae1e595160adf1f4eff3b5a8ac38cdeb48fbd6.yml -openapi_spec_hash: 8d36892345fa74be42d2fb10b1d19ab6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6803f43832a4ba37348dfc1daefe5f60f2472b76c73c286257ca370248d64e75.yml +openapi_spec_hash: 44d9bed4803ac9f98419df9e0ad1c485 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 95e0c895abd15445cef275770839af585f73057e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 03:22:41 +0000 Subject: [PATCH 0622/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9b68d1bc..b1572bf4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6803f43832a4ba37348dfc1daefe5f60f2472b76c73c286257ca370248d64e75.yml -openapi_spec_hash: 44d9bed4803ac9f98419df9e0ad1c485 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6dbb005f57f2e54c00322ee75bae1e595160adf1f4eff3b5a8ac38cdeb48fbd6.yml +openapi_spec_hash: 8d36892345fa74be42d2fb10b1d19ab6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 54a6970ec00171fe70cc819d4ab3b068804c9ab1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 04:22:36 +0000 Subject: [PATCH 0623/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index b1572bf4..9b68d1bc 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6dbb005f57f2e54c00322ee75bae1e595160adf1f4eff3b5a8ac38cdeb48fbd6.yml -openapi_spec_hash: 8d36892345fa74be42d2fb10b1d19ab6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6803f43832a4ba37348dfc1daefe5f60f2472b76c73c286257ca370248d64e75.yml +openapi_spec_hash: 44d9bed4803ac9f98419df9e0ad1c485 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 9665677417caaf6dc90128f077bc8b688f5e218a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 06:22:45 +0000 Subject: [PATCH 0624/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9b68d1bc..b1572bf4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6803f43832a4ba37348dfc1daefe5f60f2472b76c73c286257ca370248d64e75.yml -openapi_spec_hash: 44d9bed4803ac9f98419df9e0ad1c485 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6dbb005f57f2e54c00322ee75bae1e595160adf1f4eff3b5a8ac38cdeb48fbd6.yml +openapi_spec_hash: 8d36892345fa74be42d2fb10b1d19ab6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From e5a33233037800e598d6d34453b5a5a4a1b3c667 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 07:22:49 +0000 Subject: [PATCH 0625/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index b1572bf4..9b68d1bc 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6dbb005f57f2e54c00322ee75bae1e595160adf1f4eff3b5a8ac38cdeb48fbd6.yml -openapi_spec_hash: 8d36892345fa74be42d2fb10b1d19ab6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6803f43832a4ba37348dfc1daefe5f60f2472b76c73c286257ca370248d64e75.yml +openapi_spec_hash: 44d9bed4803ac9f98419df9e0ad1c485 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 1d70f889b93c7d80e5823cf343ea52ebc6114046 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 09:22:35 +0000 Subject: [PATCH 0626/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9b68d1bc..b1572bf4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6803f43832a4ba37348dfc1daefe5f60f2472b76c73c286257ca370248d64e75.yml -openapi_spec_hash: 44d9bed4803ac9f98419df9e0ad1c485 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6dbb005f57f2e54c00322ee75bae1e595160adf1f4eff3b5a8ac38cdeb48fbd6.yml +openapi_spec_hash: 8d36892345fa74be42d2fb10b1d19ab6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 1adc61fa215be9d62fd9af5ba73f3b436f1a249f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 10:22:41 +0000 Subject: [PATCH 0627/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index b1572bf4..9b68d1bc 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6dbb005f57f2e54c00322ee75bae1e595160adf1f4eff3b5a8ac38cdeb48fbd6.yml -openapi_spec_hash: 8d36892345fa74be42d2fb10b1d19ab6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6803f43832a4ba37348dfc1daefe5f60f2472b76c73c286257ca370248d64e75.yml +openapi_spec_hash: 44d9bed4803ac9f98419df9e0ad1c485 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 7902ec582b7aca09c78cba71234fb58e60367e23 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 11:22:41 +0000 Subject: [PATCH 0628/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9b68d1bc..b1572bf4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6803f43832a4ba37348dfc1daefe5f60f2472b76c73c286257ca370248d64e75.yml -openapi_spec_hash: 44d9bed4803ac9f98419df9e0ad1c485 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6dbb005f57f2e54c00322ee75bae1e595160adf1f4eff3b5a8ac38cdeb48fbd6.yml +openapi_spec_hash: 8d36892345fa74be42d2fb10b1d19ab6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 3aa5bc86ce2cb676d9bc7d79ea4b39f3dab13e44 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 12:22:54 +0000 Subject: [PATCH 0629/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index b1572bf4..9b68d1bc 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6dbb005f57f2e54c00322ee75bae1e595160adf1f4eff3b5a8ac38cdeb48fbd6.yml -openapi_spec_hash: 8d36892345fa74be42d2fb10b1d19ab6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6803f43832a4ba37348dfc1daefe5f60f2472b76c73c286257ca370248d64e75.yml +openapi_spec_hash: 44d9bed4803ac9f98419df9e0ad1c485 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 88685b053021ce92f0b0c11f6f9f7ff46861008f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 16:22:42 +0000 Subject: [PATCH 0630/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9b68d1bc..b1572bf4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6803f43832a4ba37348dfc1daefe5f60f2472b76c73c286257ca370248d64e75.yml -openapi_spec_hash: 44d9bed4803ac9f98419df9e0ad1c485 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6dbb005f57f2e54c00322ee75bae1e595160adf1f4eff3b5a8ac38cdeb48fbd6.yml +openapi_spec_hash: 8d36892345fa74be42d2fb10b1d19ab6 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 204f5c866b1f59e12e3b56dbec85eaf548899086 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 18:54:00 +0000 Subject: [PATCH 0631/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 170d70a9..13136000 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.27" + ".": "0.4.28" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 36a3b78a..ad99f372 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.27" +version = "0.4.28" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 8c2cf0d1..b6dbf0d4 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.27" # x-release-please-version +__version__ = "0.4.28" # x-release-please-version From db38d62d1b82376a262e3678a45dc80d24c27079 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 20:22:45 +0000 Subject: [PATCH 0632/1108] feat(api): api update --- .stats.yml | 4 +- api.md | 6 +- src/agentex/resources/tasks.py | 62 ++++++++--- src/agentex/types/__init__.py | 4 + src/agentex/types/task_list_params.py | 6 +- src/agentex/types/task_list_response.py | 33 +++++- .../types/task_retrieve_by_name_params.py | 12 +++ .../types/task_retrieve_by_name_response.py | 30 ++++++ src/agentex/types/task_retrieve_params.py | 12 +++ src/agentex/types/task_retrieve_response.py | 30 ++++++ tests/api_resources/test_tasks.py | 100 +++++++++++++----- 11 files changed, 243 insertions(+), 56 deletions(-) create mode 100644 src/agentex/types/task_retrieve_by_name_params.py create mode 100644 src/agentex/types/task_retrieve_by_name_response.py create mode 100644 src/agentex/types/task_retrieve_params.py create mode 100644 src/agentex/types/task_retrieve_response.py diff --git a/.stats.yml b/.stats.yml index b1572bf4..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6dbb005f57f2e54c00322ee75bae1e595160adf1f4eff3b5a8ac38cdeb48fbd6.yml -openapi_spec_hash: 8d36892345fa74be42d2fb10b1d19ab6 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 diff --git a/api.md b/api.md index 4e3e6f83..2b397d0c 100644 --- a/api.md +++ b/api.md @@ -43,16 +43,16 @@ Methods: Types: ```python -from agentex.types import Task, TaskListResponse +from agentex.types import Task, TaskRetrieveResponse, TaskListResponse, TaskRetrieveByNameResponse ``` Methods: -- client.tasks.retrieve(task_id) -> Task +- client.tasks.retrieve(task_id, \*\*params) -> TaskRetrieveResponse - client.tasks.list(\*\*params) -> TaskListResponse - client.tasks.delete(task_id) -> DeleteResponse - client.tasks.delete_by_name(task_name) -> DeleteResponse -- client.tasks.retrieve_by_name(task_name) -> Task +- client.tasks.retrieve_by_name(task_name, \*\*params) -> TaskRetrieveByNameResponse - client.tasks.stream_events(task_id) -> object - client.tasks.stream_events_by_name(task_name) -> object diff --git a/src/agentex/resources/tasks.py b/src/agentex/resources/tasks.py index 5d0547cd..33a4648d 100644 --- a/src/agentex/resources/tasks.py +++ b/src/agentex/resources/tasks.py @@ -2,11 +2,12 @@ from __future__ import annotations -from typing import Optional +from typing import List, Optional +from typing_extensions import Literal import httpx -from ..types import task_list_params +from ..types import task_list_params, task_retrieve_params, task_retrieve_by_name_params from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property @@ -18,10 +19,11 @@ async_to_streamed_response_wrapper, ) from .._streaming import Stream, AsyncStream -from ..types.task import Task from .._base_client import make_request_options from ..types.task_list_response import TaskListResponse from ..types.shared.delete_response import DeleteResponse +from ..types.task_retrieve_response import TaskRetrieveResponse +from ..types.task_retrieve_by_name_response import TaskRetrieveByNameResponse __all__ = ["TasksResource", "AsyncTasksResource"] @@ -50,13 +52,14 @@ def retrieve( self, task_id: str, *, + relationships: List[Literal["agents"]] | 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, - ) -> Task: + ) -> TaskRetrieveResponse: """ Get a task by its unique ID. @@ -74,9 +77,13 @@ def retrieve( return self._get( f"/tasks/{task_id}", options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform({"relationships": relationships}, task_retrieve_params.TaskRetrieveParams), ), - cast_to=Task, + cast_to=TaskRetrieveResponse, ) def list( @@ -86,6 +93,7 @@ def list( agent_name: Optional[str] | Omit = omit, limit: int | Omit = omit, page_number: int | Omit = omit, + relationships: List[Literal["agents"]] | 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, @@ -118,6 +126,7 @@ def list( "agent_name": agent_name, "limit": limit, "page_number": page_number, + "relationships": relationships, }, task_list_params.TaskListParams, ), @@ -195,13 +204,14 @@ def retrieve_by_name( self, task_name: str, *, + relationships: List[Literal["agents"]] | 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, - ) -> Task: + ) -> TaskRetrieveByNameResponse: """ Get a task by its unique name. @@ -219,9 +229,15 @@ def retrieve_by_name( return self._get( f"/tasks/name/{task_name}", options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + {"relationships": relationships}, task_retrieve_by_name_params.TaskRetrieveByNameParams + ), ), - cast_to=Task, + cast_to=TaskRetrieveByNameResponse, ) def stream_events( @@ -319,13 +335,14 @@ async def retrieve( self, task_id: str, *, + relationships: List[Literal["agents"]] | 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, - ) -> Task: + ) -> TaskRetrieveResponse: """ Get a task by its unique ID. @@ -343,9 +360,15 @@ async def retrieve( return await self._get( f"/tasks/{task_id}", options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + {"relationships": relationships}, task_retrieve_params.TaskRetrieveParams + ), ), - cast_to=Task, + cast_to=TaskRetrieveResponse, ) async def list( @@ -355,6 +378,7 @@ async def list( agent_name: Optional[str] | Omit = omit, limit: int | Omit = omit, page_number: int | Omit = omit, + relationships: List[Literal["agents"]] | 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, @@ -387,6 +411,7 @@ async def list( "agent_name": agent_name, "limit": limit, "page_number": page_number, + "relationships": relationships, }, task_list_params.TaskListParams, ), @@ -464,13 +489,14 @@ async def retrieve_by_name( self, task_name: str, *, + relationships: List[Literal["agents"]] | 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, - ) -> Task: + ) -> TaskRetrieveByNameResponse: """ Get a task by its unique name. @@ -488,9 +514,15 @@ async def retrieve_by_name( return await self._get( f"/tasks/name/{task_name}", options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + {"relationships": relationships}, task_retrieve_by_name_params.TaskRetrieveByNameParams + ), ), - cast_to=Task, + cast_to=TaskRetrieveByNameResponse, ) async def stream_events( diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 0445dfad..47e148bb 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -45,6 +45,7 @@ from .tool_response_delta import ToolResponseDelta as ToolResponseDelta from .tracker_list_params import TrackerListParams as TrackerListParams from .task_message_content import TaskMessageContent as TaskMessageContent +from .task_retrieve_params import TaskRetrieveParams as TaskRetrieveParams from .tool_request_content import ToolRequestContent as ToolRequestContent from .message_create_params import MessageCreateParams as MessageCreateParams from .message_list_response import MessageListResponse as MessageListResponse @@ -52,6 +53,7 @@ from .tool_response_content import ToolResponseContent as ToolResponseContent from .tracker_list_response import TrackerListResponse as TrackerListResponse from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams +from .task_retrieve_response import TaskRetrieveResponse as TaskRetrieveResponse from .reasoning_content_delta import ReasoningContentDelta as ReasoningContentDelta from .reasoning_content_param import ReasoningContentParam as ReasoningContentParam from .reasoning_summary_delta import ReasoningSummaryDelta as ReasoningSummaryDelta @@ -59,3 +61,5 @@ from .task_message_content_param import TaskMessageContentParam as TaskMessageContentParam from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam +from .task_retrieve_by_name_params import TaskRetrieveByNameParams as TaskRetrieveByNameParams +from .task_retrieve_by_name_response import TaskRetrieveByNameResponse as TaskRetrieveByNameResponse diff --git a/src/agentex/types/task_list_params.py b/src/agentex/types/task_list_params.py index 94be17f9..6c417eb0 100644 --- a/src/agentex/types/task_list_params.py +++ b/src/agentex/types/task_list_params.py @@ -2,8 +2,8 @@ from __future__ import annotations -from typing import Optional -from typing_extensions import TypedDict +from typing import List, Optional +from typing_extensions import Literal, TypedDict __all__ = ["TaskListParams"] @@ -16,3 +16,5 @@ class TaskListParams(TypedDict, total=False): limit: int page_number: int + + relationships: List[Literal["agents"]] diff --git a/src/agentex/types/task_list_response.py b/src/agentex/types/task_list_response.py index c9607e60..745c9fbe 100644 --- a/src/agentex/types/task_list_response.py +++ b/src/agentex/types/task_list_response.py @@ -1,10 +1,33 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import List -from typing_extensions import TypeAlias +from typing import Dict, List, Optional +from datetime import datetime +from typing_extensions import Literal, TypeAlias -from .task import Task +from .agent import Agent +from .._models import BaseModel -__all__ = ["TaskListResponse"] +__all__ = ["TaskListResponse", "TaskListResponseItem"] -TaskListResponse: TypeAlias = List[Task] + +class TaskListResponseItem(BaseModel): + id: str + + agents: Optional[List[Agent]] = None + + created_at: Optional[datetime] = None + + name: Optional[str] = None + + params: Optional[Dict[str, object]] = None + + status: Optional[Literal["CANCELED", "COMPLETED", "FAILED", "RUNNING", "TERMINATED", "TIMED_OUT", "DELETED"]] = None + + status_reason: Optional[str] = None + + task_metadata: Optional[Dict[str, object]] = None + + updated_at: Optional[datetime] = None + + +TaskListResponse: TypeAlias = List[TaskListResponseItem] diff --git a/src/agentex/types/task_retrieve_by_name_params.py b/src/agentex/types/task_retrieve_by_name_params.py new file mode 100644 index 00000000..98d03982 --- /dev/null +++ b/src/agentex/types/task_retrieve_by_name_params.py @@ -0,0 +1,12 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List +from typing_extensions import Literal, TypedDict + +__all__ = ["TaskRetrieveByNameParams"] + + +class TaskRetrieveByNameParams(TypedDict, total=False): + relationships: List[Literal["agents"]] diff --git a/src/agentex/types/task_retrieve_by_name_response.py b/src/agentex/types/task_retrieve_by_name_response.py new file mode 100644 index 00000000..4d8ae95d --- /dev/null +++ b/src/agentex/types/task_retrieve_by_name_response.py @@ -0,0 +1,30 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict, List, Optional +from datetime import datetime +from typing_extensions import Literal + +from .agent import Agent +from .._models import BaseModel + +__all__ = ["TaskRetrieveByNameResponse"] + + +class TaskRetrieveByNameResponse(BaseModel): + id: str + + agents: Optional[List[Agent]] = None + + created_at: Optional[datetime] = None + + name: Optional[str] = None + + params: Optional[Dict[str, object]] = None + + status: Optional[Literal["CANCELED", "COMPLETED", "FAILED", "RUNNING", "TERMINATED", "TIMED_OUT", "DELETED"]] = None + + status_reason: Optional[str] = None + + task_metadata: Optional[Dict[str, object]] = None + + updated_at: Optional[datetime] = None diff --git a/src/agentex/types/task_retrieve_params.py b/src/agentex/types/task_retrieve_params.py new file mode 100644 index 00000000..61748a1b --- /dev/null +++ b/src/agentex/types/task_retrieve_params.py @@ -0,0 +1,12 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List +from typing_extensions import Literal, TypedDict + +__all__ = ["TaskRetrieveParams"] + + +class TaskRetrieveParams(TypedDict, total=False): + relationships: List[Literal["agents"]] diff --git a/src/agentex/types/task_retrieve_response.py b/src/agentex/types/task_retrieve_response.py new file mode 100644 index 00000000..f824b368 --- /dev/null +++ b/src/agentex/types/task_retrieve_response.py @@ -0,0 +1,30 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict, List, Optional +from datetime import datetime +from typing_extensions import Literal + +from .agent import Agent +from .._models import BaseModel + +__all__ = ["TaskRetrieveResponse"] + + +class TaskRetrieveResponse(BaseModel): + id: str + + agents: Optional[List[Agent]] = None + + created_at: Optional[datetime] = None + + name: Optional[str] = None + + params: Optional[Dict[str, object]] = None + + status: Optional[Literal["CANCELED", "COMPLETED", "FAILED", "RUNNING", "TERMINATED", "TIMED_OUT", "DELETED"]] = None + + status_reason: Optional[str] = None + + task_metadata: Optional[Dict[str, object]] = None + + updated_at: Optional[datetime] = None diff --git a/tests/api_resources/test_tasks.py b/tests/api_resources/test_tasks.py index 66e850cc..eaf05fe2 100644 --- a/tests/api_resources/test_tasks.py +++ b/tests/api_resources/test_tasks.py @@ -9,7 +9,11 @@ from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type -from agentex.types import Task, TaskListResponse +from agentex.types import ( + TaskListResponse, + TaskRetrieveResponse, + TaskRetrieveByNameResponse, +) from agentex.types.shared import DeleteResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -22,33 +26,42 @@ class TestTasks: @parametrize def test_method_retrieve(self, client: Agentex) -> None: task = client.tasks.retrieve( - "task_id", + task_id="task_id", ) - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_retrieve_with_all_params(self, client: Agentex) -> None: + task = client.tasks.retrieve( + task_id="task_id", + relationships=["agents"], + ) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.tasks.with_raw_response.retrieve( - "task_id", + task_id="task_id", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.tasks.with_streaming_response.retrieve( - "task_id", + task_id="task_id", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -57,7 +70,7 @@ def test_streaming_response_retrieve(self, client: Agentex) -> None: def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): client.tasks.with_raw_response.retrieve( - "", + task_id="", ) @pytest.mark.skip(reason="Prism tests are disabled") @@ -74,6 +87,7 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: agent_name="agent_name", limit=0, page_number=0, + relationships=["agents"], ) assert_matches_type(TaskListResponse, task, path=["response"]) @@ -187,33 +201,42 @@ def test_path_params_delete_by_name(self, client: Agentex) -> None: @parametrize def test_method_retrieve_by_name(self, client: Agentex) -> None: task = client.tasks.retrieve_by_name( - "task_name", + task_name="task_name", ) - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_retrieve_by_name_with_all_params(self, client: Agentex) -> None: + task = client.tasks.retrieve_by_name( + task_name="task_name", + relationships=["agents"], + ) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve_by_name(self, client: Agentex) -> None: response = client.tasks.with_raw_response.retrieve_by_name( - "task_name", + task_name="task_name", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve_by_name(self, client: Agentex) -> None: with client.tasks.with_streaming_response.retrieve_by_name( - "task_name", + task_name="task_name", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -222,7 +245,7 @@ def test_streaming_response_retrieve_by_name(self, client: Agentex) -> None: def test_path_params_retrieve_by_name(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): client.tasks.with_raw_response.retrieve_by_name( - "", + task_name="", ) @pytest.mark.skip(reason="Prism tests are disabled") @@ -317,33 +340,42 @@ class TestAsyncTasks: @parametrize async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.retrieve( - "task_id", + task_id="task_id", ) - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_retrieve_with_all_params(self, async_client: AsyncAgentex) -> None: + task = await async_client.tasks.retrieve( + task_id="task_id", + relationships=["agents"], + ) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.retrieve( - "task_id", + task_id="task_id", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.retrieve( - "task_id", + task_id="task_id", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -352,7 +384,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): await async_client.tasks.with_raw_response.retrieve( - "", + task_id="", ) @pytest.mark.skip(reason="Prism tests are disabled") @@ -369,6 +401,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> agent_name="agent_name", limit=0, page_number=0, + relationships=["agents"], ) assert_matches_type(TaskListResponse, task, path=["response"]) @@ -482,33 +515,42 @@ async def test_path_params_delete_by_name(self, async_client: AsyncAgentex) -> N @parametrize async def test_method_retrieve_by_name(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.retrieve_by_name( - "task_name", + task_name="task_name", ) - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_retrieve_by_name_with_all_params(self, async_client: AsyncAgentex) -> None: + task = await async_client.tasks.retrieve_by_name( + task_name="task_name", + relationships=["agents"], + ) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve_by_name(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.retrieve_by_name( - "task_name", + task_name="task_name", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve_by_name(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.retrieve_by_name( - "task_name", + task_name="task_name", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -517,7 +559,7 @@ async def test_streaming_response_retrieve_by_name(self, async_client: AsyncAgen async def test_path_params_retrieve_by_name(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): await async_client.tasks.with_raw_response.retrieve_by_name( - "", + task_name="", ) @pytest.mark.skip(reason="Prism tests are disabled") From 1c82e98c50211593ead08f5c7e4ddac84aaf3c12 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 22:00:02 +0000 Subject: [PATCH 0633/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 13136000..2aca35ae 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.28" + ".": "0.5.0" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index ad99f372..2926a8fb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.4.28" +version = "0.5.0" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index b6dbf0d4..6d776a78 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.4.28" # x-release-please-version +__version__ = "0.5.0" # x-release-please-version From fedd263f05acbea4b94681422d660f06026b91dc Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 22:22:52 +0000 Subject: [PATCH 0634/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 77540b1a854b70db2c4e79269fa3a113cb94c415 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 28 Oct 2025 23:22:46 +0000 Subject: [PATCH 0635/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 507c2add..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From afe5d774c7d1ef1201dcb7eb1d9c18d706c4c646 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 29 Oct 2025 00:22:46 +0000 Subject: [PATCH 0636/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 818fd3cbd2c6ead3fbbe8da4d02beacd776da168 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 29 Oct 2025 01:22:46 +0000 Subject: [PATCH 0637/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 507c2add..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 6e70725c6f1f930ad7f9fefc7cfdbc1952b92740 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 29 Oct 2025 03:22:47 +0000 Subject: [PATCH 0638/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 9146455058dd72138f9b7a46e0252caab9740cca Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 29 Oct 2025 04:22:47 +0000 Subject: [PATCH 0639/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 507c2add..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From c05409eb9333649acde2ba0954228df5a306d339 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 29 Oct 2025 05:22:46 +0000 Subject: [PATCH 0640/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 5b311e87b08d3af5bf9fa24a46ec62237f04d7d9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 29 Oct 2025 07:22:52 +0000 Subject: [PATCH 0641/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 507c2add..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From bed2a61941ef3cd99ec9981d87c49b6df909cc54 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 29 Oct 2025 10:22:51 +0000 Subject: [PATCH 0642/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From f5a51f424b6eadd98446ad6219cedf2fcddfe43c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 29 Oct 2025 10:42:39 +0000 Subject: [PATCH 0643/1108] fix(client): close streams without requiring full consumption --- src/agentex/_streaming.py | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/src/agentex/_streaming.py b/src/agentex/_streaming.py index cdcb3280..ed1382cc 100644 --- a/src/agentex/_streaming.py +++ b/src/agentex/_streaming.py @@ -57,9 +57,8 @@ def __stream__(self) -> Iterator[_T]: for sse in iterator: yield process_data(data=sse.json(), cast_to=cast_to, response=response) - # Ensure the entire stream is consumed - for _sse in iterator: - ... + # As we might not fully consume the response stream, we need to close it explicitly + response.close() def __enter__(self) -> Self: return self @@ -121,9 +120,8 @@ async def __stream__(self) -> AsyncIterator[_T]: async for sse in iterator: yield process_data(data=sse.json(), cast_to=cast_to, response=response) - # Ensure the entire stream is consumed - async for _sse in iterator: - ... + # As we might not fully consume the response stream, we need to close it explicitly + await response.aclose() async def __aenter__(self) -> Self: return self From 28e4eb51f4e2c8e7da8a18264e77ebc169f7cb2d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 29 Oct 2025 15:22:48 +0000 Subject: [PATCH 0644/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 507c2add..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From dc301d72e08d8027fd1019a3c231e96df7b98168 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 30 Oct 2025 08:23:00 +0000 Subject: [PATCH 0645/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From fd068d0d8db2e0f5e48f461ac5a99f3a98ac60fe Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 30 Oct 2025 09:23:03 +0000 Subject: [PATCH 0646/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 507c2add..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 9dc7b594f7c51502e35ed8f3b3b3aa685a93e7b7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 30 Oct 2025 11:02:30 +0000 Subject: [PATCH 0647/1108] chore(internal/tests): avoid race condition with implicit client cleanup --- tests/test_client.py | 366 ++++++++++++++++++++++++------------------- 1 file changed, 202 insertions(+), 164 deletions(-) diff --git a/tests/test_client.py b/tests/test_client.py index 32b286d7..dad275e8 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -59,51 +59,49 @@ def _get_open_connections(client: Agentex | AsyncAgentex) -> int: class TestAgentex: - client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) - @pytest.mark.respx(base_url=base_url) - def test_raw_response(self, respx_mock: MockRouter) -> None: + def test_raw_response(self, respx_mock: MockRouter, client: Agentex) -> None: respx_mock.post("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"})) - response = self.client.post("/foo", cast_to=httpx.Response) + response = client.post("/foo", cast_to=httpx.Response) assert response.status_code == 200 assert isinstance(response, httpx.Response) assert response.json() == {"foo": "bar"} @pytest.mark.respx(base_url=base_url) - def test_raw_response_for_binary(self, respx_mock: MockRouter) -> None: + def test_raw_response_for_binary(self, respx_mock: MockRouter, client: Agentex) -> None: respx_mock.post("/foo").mock( return_value=httpx.Response(200, headers={"Content-Type": "application/binary"}, content='{"foo": "bar"}') ) - response = self.client.post("/foo", cast_to=httpx.Response) + response = client.post("/foo", cast_to=httpx.Response) assert response.status_code == 200 assert isinstance(response, httpx.Response) assert response.json() == {"foo": "bar"} - def test_copy(self) -> None: - copied = self.client.copy() - assert id(copied) != id(self.client) + def test_copy(self, client: Agentex) -> None: + copied = client.copy() + assert id(copied) != id(client) - copied = self.client.copy(api_key="another My API Key") + copied = client.copy(api_key="another My API Key") assert copied.api_key == "another My API Key" - assert self.client.api_key == "My API Key" + assert client.api_key == "My API Key" - def test_copy_default_options(self) -> None: + def test_copy_default_options(self, client: Agentex) -> None: # options that have a default are overridden correctly - copied = self.client.copy(max_retries=7) + copied = client.copy(max_retries=7) assert copied.max_retries == 7 - assert self.client.max_retries == 2 + assert client.max_retries == 2 copied2 = copied.copy(max_retries=6) assert copied2.max_retries == 6 assert copied.max_retries == 7 # timeout - assert isinstance(self.client.timeout, httpx.Timeout) - copied = self.client.copy(timeout=None) + assert isinstance(client.timeout, httpx.Timeout) + copied = client.copy(timeout=None) assert copied.timeout is None - assert isinstance(self.client.timeout, httpx.Timeout) + assert isinstance(client.timeout, httpx.Timeout) def test_copy_default_headers(self) -> None: client = Agentex( @@ -138,6 +136,7 @@ def test_copy_default_headers(self) -> None: match="`default_headers` and `set_default_headers` arguments are mutually exclusive", ): client.copy(set_default_headers={}, default_headers={"X-Foo": "Bar"}) + client.close() def test_copy_default_query(self) -> None: client = Agentex( @@ -175,13 +174,15 @@ def test_copy_default_query(self) -> None: ): client.copy(set_default_query={}, default_query={"foo": "Bar"}) - def test_copy_signature(self) -> None: + client.close() + + def test_copy_signature(self, client: Agentex) -> None: # ensure the same parameters that can be passed to the client are defined in the `.copy()` method init_signature = inspect.signature( # mypy doesn't like that we access the `__init__` property. - self.client.__init__, # type: ignore[misc] + client.__init__, # type: ignore[misc] ) - copy_signature = inspect.signature(self.client.copy) + copy_signature = inspect.signature(client.copy) exclude_params = {"transport", "proxies", "_strict_response_validation"} for name in init_signature.parameters.keys(): @@ -192,12 +193,12 @@ def test_copy_signature(self) -> None: assert copy_param is not None, f"copy() signature is missing the {name} param" @pytest.mark.skipif(sys.version_info >= (3, 10), reason="fails because of a memory leak that started from 3.12") - def test_copy_build_request(self) -> None: + def test_copy_build_request(self, client: Agentex) -> None: options = FinalRequestOptions(method="get", url="/foo") def build_request(options: FinalRequestOptions) -> None: - client = self.client.copy() - client._build_request(options) + client_copy = client.copy() + client_copy._build_request(options) # ensure that the machinery is warmed up before tracing starts. build_request(options) @@ -254,14 +255,12 @@ def add_leak(leaks: list[tracemalloc.StatisticDiff], diff: tracemalloc.Statistic print(frame) raise AssertionError() - def test_request_timeout(self) -> None: - request = self.client._build_request(FinalRequestOptions(method="get", url="/foo")) + def test_request_timeout(self, client: Agentex) -> None: + request = client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore assert timeout == DEFAULT_TIMEOUT - request = self.client._build_request( - FinalRequestOptions(method="get", url="/foo", timeout=httpx.Timeout(100.0)) - ) + request = client._build_request(FinalRequestOptions(method="get", url="/foo", timeout=httpx.Timeout(100.0))) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore assert timeout == httpx.Timeout(100.0) @@ -272,6 +271,8 @@ def test_client_timeout_option(self) -> None: timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore assert timeout == httpx.Timeout(0) + client.close() + def test_http_client_timeout_option(self) -> None: # custom timeout given to the httpx client should be used with httpx.Client(timeout=None) as http_client: @@ -283,6 +284,8 @@ def test_http_client_timeout_option(self) -> None: timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore assert timeout == httpx.Timeout(None) + client.close() + # no timeout given to the httpx client should not use the httpx default with httpx.Client() as http_client: client = Agentex( @@ -293,6 +296,8 @@ def test_http_client_timeout_option(self) -> None: timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore assert timeout == DEFAULT_TIMEOUT + client.close() + # explicitly passing the default timeout currently results in it being ignored with httpx.Client(timeout=HTTPX_DEFAULT_TIMEOUT) as http_client: client = Agentex( @@ -303,6 +308,8 @@ def test_http_client_timeout_option(self) -> None: timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore assert timeout == DEFAULT_TIMEOUT # our default + client.close() + async def test_invalid_http_client(self) -> None: with pytest.raises(TypeError, match="Invalid `http_client` arg"): async with httpx.AsyncClient() as http_client: @@ -314,14 +321,14 @@ async def test_invalid_http_client(self) -> None: ) def test_default_headers_option(self) -> None: - client = Agentex( + test_client = Agentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} ) - request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + request = test_client._build_request(FinalRequestOptions(method="get", url="/foo")) assert request.headers.get("x-foo") == "bar" assert request.headers.get("x-stainless-lang") == "python" - client2 = Agentex( + test_client2 = Agentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, @@ -330,10 +337,13 @@ def test_default_headers_option(self) -> None: "X-Stainless-Lang": "my-overriding-header", }, ) - request = client2._build_request(FinalRequestOptions(method="get", url="/foo")) + request = test_client2._build_request(FinalRequestOptions(method="get", url="/foo")) assert request.headers.get("x-foo") == "stainless" assert request.headers.get("x-stainless-lang") == "my-overriding-header" + test_client.close() + test_client2.close() + def test_validate_headers(self) -> None: client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) @@ -362,8 +372,10 @@ def test_default_query_option(self) -> None: url = httpx.URL(request.url) assert dict(url.params) == {"foo": "baz", "query_param": "overridden"} - def test_request_extra_json(self) -> None: - request = self.client._build_request( + client.close() + + def test_request_extra_json(self, client: Agentex) -> None: + request = client._build_request( FinalRequestOptions( method="post", url="/foo", @@ -374,7 +386,7 @@ def test_request_extra_json(self) -> None: data = json.loads(request.content.decode("utf-8")) assert data == {"foo": "bar", "baz": False} - request = self.client._build_request( + request = client._build_request( FinalRequestOptions( method="post", url="/foo", @@ -385,7 +397,7 @@ def test_request_extra_json(self) -> None: assert data == {"baz": False} # `extra_json` takes priority over `json_data` when keys clash - request = self.client._build_request( + request = client._build_request( FinalRequestOptions( method="post", url="/foo", @@ -396,8 +408,8 @@ def test_request_extra_json(self) -> None: data = json.loads(request.content.decode("utf-8")) assert data == {"foo": "bar", "baz": None} - def test_request_extra_headers(self) -> None: - request = self.client._build_request( + def test_request_extra_headers(self, client: Agentex) -> None: + request = client._build_request( FinalRequestOptions( method="post", url="/foo", @@ -407,7 +419,7 @@ def test_request_extra_headers(self) -> None: assert request.headers.get("X-Foo") == "Foo" # `extra_headers` takes priority over `default_headers` when keys clash - request = self.client.with_options(default_headers={"X-Bar": "true"})._build_request( + request = client.with_options(default_headers={"X-Bar": "true"})._build_request( FinalRequestOptions( method="post", url="/foo", @@ -418,8 +430,8 @@ def test_request_extra_headers(self) -> None: ) assert request.headers.get("X-Bar") == "false" - def test_request_extra_query(self) -> None: - request = self.client._build_request( + def test_request_extra_query(self, client: Agentex) -> None: + request = client._build_request( FinalRequestOptions( method="post", url="/foo", @@ -432,7 +444,7 @@ def test_request_extra_query(self) -> None: assert params == {"my_query_param": "Foo"} # if both `query` and `extra_query` are given, they are merged - request = self.client._build_request( + request = client._build_request( FinalRequestOptions( method="post", url="/foo", @@ -446,7 +458,7 @@ def test_request_extra_query(self) -> None: assert params == {"bar": "1", "foo": "2"} # `extra_query` takes priority over `query` when keys clash - request = self.client._build_request( + request = client._build_request( FinalRequestOptions( method="post", url="/foo", @@ -489,7 +501,7 @@ def test_multipart_repeating_array(self, client: Agentex) -> None: ] @pytest.mark.respx(base_url=base_url) - def test_basic_union_response(self, respx_mock: MockRouter) -> None: + def test_basic_union_response(self, respx_mock: MockRouter, client: Agentex) -> None: class Model1(BaseModel): name: str @@ -498,12 +510,12 @@ class Model2(BaseModel): respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"})) - response = self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) + response = client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) assert isinstance(response, Model2) assert response.foo == "bar" @pytest.mark.respx(base_url=base_url) - def test_union_response_different_types(self, respx_mock: MockRouter) -> None: + def test_union_response_different_types(self, respx_mock: MockRouter, client: Agentex) -> None: """Union of objects with the same field name using a different type""" class Model1(BaseModel): @@ -514,18 +526,18 @@ class Model2(BaseModel): respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"})) - response = self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) + response = client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) assert isinstance(response, Model2) assert response.foo == "bar" respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": 1})) - response = self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) + response = client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) assert isinstance(response, Model1) assert response.foo == 1 @pytest.mark.respx(base_url=base_url) - def test_non_application_json_content_type_for_json_data(self, respx_mock: MockRouter) -> None: + def test_non_application_json_content_type_for_json_data(self, respx_mock: MockRouter, client: Agentex) -> None: """ Response that sets Content-Type to something other than application/json but returns json data """ @@ -541,7 +553,7 @@ class Model(BaseModel): ) ) - response = self.client.get("/foo", cast_to=Model) + response = client.get("/foo", cast_to=Model) assert isinstance(response, Model) assert response.foo == 2 @@ -553,6 +565,8 @@ def test_base_url_setter(self) -> None: assert client.base_url == "https://example.com/from_setter/" + client.close() + def test_base_url_env(self) -> None: with update_env(AGENTEX_BASE_URL="http://localhost:5000/from/env"): client = Agentex(api_key=api_key, _strict_response_validation=True) @@ -566,6 +580,8 @@ def test_base_url_env(self) -> None: client = Agentex(base_url=None, api_key=api_key, _strict_response_validation=True, environment="production") assert str(client.base_url).startswith("http://localhost:5003") + client.close() + @pytest.mark.parametrize( "client", [ @@ -588,6 +604,7 @@ def test_base_url_trailing_slash(self, client: Agentex) -> None: ), ) assert request.url == "http://localhost:5000/custom/path/foo" + client.close() @pytest.mark.parametrize( "client", @@ -611,6 +628,7 @@ def test_base_url_no_trailing_slash(self, client: Agentex) -> None: ), ) assert request.url == "http://localhost:5000/custom/path/foo" + client.close() @pytest.mark.parametrize( "client", @@ -634,35 +652,36 @@ def test_absolute_request_url(self, client: Agentex) -> None: ), ) assert request.url == "https://myapi.com/foo" + client.close() def test_copied_client_does_not_close_http(self) -> None: - client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) - assert not client.is_closed() + test_client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + assert not test_client.is_closed() - copied = client.copy() - assert copied is not client + copied = test_client.copy() + assert copied is not test_client del copied - assert not client.is_closed() + assert not test_client.is_closed() def test_client_context_manager(self) -> None: - client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) - with client as c2: - assert c2 is client + test_client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + with test_client as c2: + assert c2 is test_client assert not c2.is_closed() - assert not client.is_closed() - assert client.is_closed() + assert not test_client.is_closed() + assert test_client.is_closed() @pytest.mark.respx(base_url=base_url) - def test_client_response_validation_error(self, respx_mock: MockRouter) -> None: + def test_client_response_validation_error(self, respx_mock: MockRouter, client: Agentex) -> None: class Model(BaseModel): foo: str respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": {"invalid": True}})) with pytest.raises(APIResponseValidationError) as exc: - self.client.get("/foo", cast_to=Model) + client.get("/foo", cast_to=Model) assert isinstance(exc.value.__cause__, ValidationError) @@ -682,11 +701,14 @@ class Model(BaseModel): with pytest.raises(APIResponseValidationError): strict_client.get("/foo", cast_to=Model) - client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=False) + non_strict_client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=False) - response = client.get("/foo", cast_to=Model) + response = non_strict_client.get("/foo", cast_to=Model) assert isinstance(response, str) # type: ignore[unreachable] + strict_client.close() + non_strict_client.close() + @pytest.mark.parametrize( "remaining_retries,retry_after,timeout", [ @@ -709,9 +731,9 @@ class Model(BaseModel): ], ) @mock.patch("time.time", mock.MagicMock(return_value=1696004797)) - def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str, timeout: float) -> None: - client = Agentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) - + def test_parse_retry_after_header( + self, remaining_retries: int, retry_after: str, timeout: float, client: Agentex + ) -> None: headers = httpx.Headers({"retry-after": retry_after}) options = FinalRequestOptions(method="get", url="/foo", max_retries=3) calculated = client._calculate_retry_timeout(remaining_retries, options, headers) @@ -725,7 +747,7 @@ def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter, clien with pytest.raises(APITimeoutError): client.tasks.with_streaming_response.list().__enter__() - assert _get_open_connections(self.client) == 0 + assert _get_open_connections(client) == 0 @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) @@ -734,7 +756,7 @@ def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, client with pytest.raises(APIStatusError): client.tasks.with_streaming_response.list().__enter__() - assert _get_open_connections(self.client) == 0 + assert _get_open_connections(client) == 0 @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @@ -836,83 +858,77 @@ def test_default_client_creation(self) -> None: ) @pytest.mark.respx(base_url=base_url) - def test_follow_redirects(self, respx_mock: MockRouter) -> None: + def test_follow_redirects(self, respx_mock: MockRouter, client: Agentex) -> None: # Test that the default follow_redirects=True allows following redirects respx_mock.post("/redirect").mock( return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"}) ) respx_mock.get("/redirected").mock(return_value=httpx.Response(200, json={"status": "ok"})) - response = self.client.post("/redirect", body={"key": "value"}, cast_to=httpx.Response) + response = client.post("/redirect", body={"key": "value"}, cast_to=httpx.Response) assert response.status_code == 200 assert response.json() == {"status": "ok"} @pytest.mark.respx(base_url=base_url) - def test_follow_redirects_disabled(self, respx_mock: MockRouter) -> None: + def test_follow_redirects_disabled(self, respx_mock: MockRouter, client: Agentex) -> None: # Test that follow_redirects=False prevents following redirects respx_mock.post("/redirect").mock( return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"}) ) with pytest.raises(APIStatusError) as exc_info: - self.client.post( - "/redirect", body={"key": "value"}, options={"follow_redirects": False}, cast_to=httpx.Response - ) + client.post("/redirect", body={"key": "value"}, options={"follow_redirects": False}, cast_to=httpx.Response) assert exc_info.value.response.status_code == 302 assert exc_info.value.response.headers["Location"] == f"{base_url}/redirected" class TestAsyncAgentex: - client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) - @pytest.mark.respx(base_url=base_url) - @pytest.mark.asyncio - async def test_raw_response(self, respx_mock: MockRouter) -> None: + async def test_raw_response(self, respx_mock: MockRouter, async_client: AsyncAgentex) -> None: respx_mock.post("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"})) - response = await self.client.post("/foo", cast_to=httpx.Response) + response = await async_client.post("/foo", cast_to=httpx.Response) assert response.status_code == 200 assert isinstance(response, httpx.Response) assert response.json() == {"foo": "bar"} @pytest.mark.respx(base_url=base_url) - @pytest.mark.asyncio - async def test_raw_response_for_binary(self, respx_mock: MockRouter) -> None: + async def test_raw_response_for_binary(self, respx_mock: MockRouter, async_client: AsyncAgentex) -> None: respx_mock.post("/foo").mock( return_value=httpx.Response(200, headers={"Content-Type": "application/binary"}, content='{"foo": "bar"}') ) - response = await self.client.post("/foo", cast_to=httpx.Response) + response = await async_client.post("/foo", cast_to=httpx.Response) assert response.status_code == 200 assert isinstance(response, httpx.Response) assert response.json() == {"foo": "bar"} - def test_copy(self) -> None: - copied = self.client.copy() - assert id(copied) != id(self.client) + def test_copy(self, async_client: AsyncAgentex) -> None: + copied = async_client.copy() + assert id(copied) != id(async_client) - copied = self.client.copy(api_key="another My API Key") + copied = async_client.copy(api_key="another My API Key") assert copied.api_key == "another My API Key" - assert self.client.api_key == "My API Key" + assert async_client.api_key == "My API Key" - def test_copy_default_options(self) -> None: + def test_copy_default_options(self, async_client: AsyncAgentex) -> None: # options that have a default are overridden correctly - copied = self.client.copy(max_retries=7) + copied = async_client.copy(max_retries=7) assert copied.max_retries == 7 - assert self.client.max_retries == 2 + assert async_client.max_retries == 2 copied2 = copied.copy(max_retries=6) assert copied2.max_retries == 6 assert copied.max_retries == 7 # timeout - assert isinstance(self.client.timeout, httpx.Timeout) - copied = self.client.copy(timeout=None) + assert isinstance(async_client.timeout, httpx.Timeout) + copied = async_client.copy(timeout=None) assert copied.timeout is None - assert isinstance(self.client.timeout, httpx.Timeout) + assert isinstance(async_client.timeout, httpx.Timeout) - def test_copy_default_headers(self) -> None: + async def test_copy_default_headers(self) -> None: client = AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} ) @@ -945,8 +961,9 @@ def test_copy_default_headers(self) -> None: match="`default_headers` and `set_default_headers` arguments are mutually exclusive", ): client.copy(set_default_headers={}, default_headers={"X-Foo": "Bar"}) + await client.close() - def test_copy_default_query(self) -> None: + async def test_copy_default_query(self) -> None: client = AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"foo": "bar"} ) @@ -982,13 +999,15 @@ def test_copy_default_query(self) -> None: ): client.copy(set_default_query={}, default_query={"foo": "Bar"}) - def test_copy_signature(self) -> None: + await client.close() + + def test_copy_signature(self, async_client: AsyncAgentex) -> None: # ensure the same parameters that can be passed to the client are defined in the `.copy()` method init_signature = inspect.signature( # mypy doesn't like that we access the `__init__` property. - self.client.__init__, # type: ignore[misc] + async_client.__init__, # type: ignore[misc] ) - copy_signature = inspect.signature(self.client.copy) + copy_signature = inspect.signature(async_client.copy) exclude_params = {"transport", "proxies", "_strict_response_validation"} for name in init_signature.parameters.keys(): @@ -999,12 +1018,12 @@ def test_copy_signature(self) -> None: assert copy_param is not None, f"copy() signature is missing the {name} param" @pytest.mark.skipif(sys.version_info >= (3, 10), reason="fails because of a memory leak that started from 3.12") - def test_copy_build_request(self) -> None: + def test_copy_build_request(self, async_client: AsyncAgentex) -> None: options = FinalRequestOptions(method="get", url="/foo") def build_request(options: FinalRequestOptions) -> None: - client = self.client.copy() - client._build_request(options) + client_copy = async_client.copy() + client_copy._build_request(options) # ensure that the machinery is warmed up before tracing starts. build_request(options) @@ -1061,12 +1080,12 @@ def add_leak(leaks: list[tracemalloc.StatisticDiff], diff: tracemalloc.Statistic print(frame) raise AssertionError() - async def test_request_timeout(self) -> None: - request = self.client._build_request(FinalRequestOptions(method="get", url="/foo")) + async def test_request_timeout(self, async_client: AsyncAgentex) -> None: + request = async_client._build_request(FinalRequestOptions(method="get", url="/foo")) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore assert timeout == DEFAULT_TIMEOUT - request = self.client._build_request( + request = async_client._build_request( FinalRequestOptions(method="get", url="/foo", timeout=httpx.Timeout(100.0)) ) timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore @@ -1081,6 +1100,8 @@ async def test_client_timeout_option(self) -> None: timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore assert timeout == httpx.Timeout(0) + await client.close() + async def test_http_client_timeout_option(self) -> None: # custom timeout given to the httpx client should be used async with httpx.AsyncClient(timeout=None) as http_client: @@ -1092,6 +1113,8 @@ async def test_http_client_timeout_option(self) -> None: timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore assert timeout == httpx.Timeout(None) + await client.close() + # no timeout given to the httpx client should not use the httpx default async with httpx.AsyncClient() as http_client: client = AsyncAgentex( @@ -1102,6 +1125,8 @@ async def test_http_client_timeout_option(self) -> None: timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore assert timeout == DEFAULT_TIMEOUT + await client.close() + # explicitly passing the default timeout currently results in it being ignored async with httpx.AsyncClient(timeout=HTTPX_DEFAULT_TIMEOUT) as http_client: client = AsyncAgentex( @@ -1112,6 +1137,8 @@ async def test_http_client_timeout_option(self) -> None: timeout = httpx.Timeout(**request.extensions["timeout"]) # type: ignore assert timeout == DEFAULT_TIMEOUT # our default + await client.close() + def test_invalid_http_client(self) -> None: with pytest.raises(TypeError, match="Invalid `http_client` arg"): with httpx.Client() as http_client: @@ -1122,15 +1149,15 @@ def test_invalid_http_client(self) -> None: http_client=cast(Any, http_client), ) - def test_default_headers_option(self) -> None: - client = AsyncAgentex( + async def test_default_headers_option(self) -> None: + test_client = AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"} ) - request = client._build_request(FinalRequestOptions(method="get", url="/foo")) + request = test_client._build_request(FinalRequestOptions(method="get", url="/foo")) assert request.headers.get("x-foo") == "bar" assert request.headers.get("x-stainless-lang") == "python" - client2 = AsyncAgentex( + test_client2 = AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, @@ -1139,10 +1166,13 @@ def test_default_headers_option(self) -> None: "X-Stainless-Lang": "my-overriding-header", }, ) - request = client2._build_request(FinalRequestOptions(method="get", url="/foo")) + request = test_client2._build_request(FinalRequestOptions(method="get", url="/foo")) assert request.headers.get("x-foo") == "stainless" assert request.headers.get("x-stainless-lang") == "my-overriding-header" + await test_client.close() + await test_client2.close() + def test_validate_headers(self) -> None: client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) request = client._build_request(FinalRequestOptions(method="get", url="/foo")) @@ -1153,7 +1183,7 @@ def test_validate_headers(self) -> None: client2._build_request(FinalRequestOptions(method="get", url="/foo")) - def test_default_query_option(self) -> None: + async def test_default_query_option(self) -> None: client = AsyncAgentex( base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"query_param": "bar"} ) @@ -1171,8 +1201,10 @@ def test_default_query_option(self) -> None: url = httpx.URL(request.url) assert dict(url.params) == {"foo": "baz", "query_param": "overridden"} - def test_request_extra_json(self) -> None: - request = self.client._build_request( + await client.close() + + def test_request_extra_json(self, client: Agentex) -> None: + request = client._build_request( FinalRequestOptions( method="post", url="/foo", @@ -1183,7 +1215,7 @@ def test_request_extra_json(self) -> None: data = json.loads(request.content.decode("utf-8")) assert data == {"foo": "bar", "baz": False} - request = self.client._build_request( + request = client._build_request( FinalRequestOptions( method="post", url="/foo", @@ -1194,7 +1226,7 @@ def test_request_extra_json(self) -> None: assert data == {"baz": False} # `extra_json` takes priority over `json_data` when keys clash - request = self.client._build_request( + request = client._build_request( FinalRequestOptions( method="post", url="/foo", @@ -1205,8 +1237,8 @@ def test_request_extra_json(self) -> None: data = json.loads(request.content.decode("utf-8")) assert data == {"foo": "bar", "baz": None} - def test_request_extra_headers(self) -> None: - request = self.client._build_request( + def test_request_extra_headers(self, client: Agentex) -> None: + request = client._build_request( FinalRequestOptions( method="post", url="/foo", @@ -1216,7 +1248,7 @@ def test_request_extra_headers(self) -> None: assert request.headers.get("X-Foo") == "Foo" # `extra_headers` takes priority over `default_headers` when keys clash - request = self.client.with_options(default_headers={"X-Bar": "true"})._build_request( + request = client.with_options(default_headers={"X-Bar": "true"})._build_request( FinalRequestOptions( method="post", url="/foo", @@ -1227,8 +1259,8 @@ def test_request_extra_headers(self) -> None: ) assert request.headers.get("X-Bar") == "false" - def test_request_extra_query(self) -> None: - request = self.client._build_request( + def test_request_extra_query(self, client: Agentex) -> None: + request = client._build_request( FinalRequestOptions( method="post", url="/foo", @@ -1241,7 +1273,7 @@ def test_request_extra_query(self) -> None: assert params == {"my_query_param": "Foo"} # if both `query` and `extra_query` are given, they are merged - request = self.client._build_request( + request = client._build_request( FinalRequestOptions( method="post", url="/foo", @@ -1255,7 +1287,7 @@ def test_request_extra_query(self) -> None: assert params == {"bar": "1", "foo": "2"} # `extra_query` takes priority over `query` when keys clash - request = self.client._build_request( + request = client._build_request( FinalRequestOptions( method="post", url="/foo", @@ -1298,7 +1330,7 @@ def test_multipart_repeating_array(self, async_client: AsyncAgentex) -> None: ] @pytest.mark.respx(base_url=base_url) - async def test_basic_union_response(self, respx_mock: MockRouter) -> None: + async def test_basic_union_response(self, respx_mock: MockRouter, async_client: AsyncAgentex) -> None: class Model1(BaseModel): name: str @@ -1307,12 +1339,12 @@ class Model2(BaseModel): respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"})) - response = await self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) + response = await async_client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) assert isinstance(response, Model2) assert response.foo == "bar" @pytest.mark.respx(base_url=base_url) - async def test_union_response_different_types(self, respx_mock: MockRouter) -> None: + async def test_union_response_different_types(self, respx_mock: MockRouter, async_client: AsyncAgentex) -> None: """Union of objects with the same field name using a different type""" class Model1(BaseModel): @@ -1323,18 +1355,20 @@ class Model2(BaseModel): respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"})) - response = await self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) + response = await async_client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) assert isinstance(response, Model2) assert response.foo == "bar" respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": 1})) - response = await self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) + response = await async_client.get("/foo", cast_to=cast(Any, Union[Model1, Model2])) assert isinstance(response, Model1) assert response.foo == 1 @pytest.mark.respx(base_url=base_url) - async def test_non_application_json_content_type_for_json_data(self, respx_mock: MockRouter) -> None: + async def test_non_application_json_content_type_for_json_data( + self, respx_mock: MockRouter, async_client: AsyncAgentex + ) -> None: """ Response that sets Content-Type to something other than application/json but returns json data """ @@ -1350,11 +1384,11 @@ class Model(BaseModel): ) ) - response = await self.client.get("/foo", cast_to=Model) + response = await async_client.get("/foo", cast_to=Model) assert isinstance(response, Model) assert response.foo == 2 - def test_base_url_setter(self) -> None: + async def test_base_url_setter(self) -> None: client = AsyncAgentex( base_url="https://example.com/from_init", api_key=api_key, _strict_response_validation=True ) @@ -1364,7 +1398,9 @@ def test_base_url_setter(self) -> None: assert client.base_url == "https://example.com/from_setter/" - def test_base_url_env(self) -> None: + await client.close() + + async def test_base_url_env(self) -> None: with update_env(AGENTEX_BASE_URL="http://localhost:5000/from/env"): client = AsyncAgentex(api_key=api_key, _strict_response_validation=True) assert client.base_url == "http://localhost:5000/from/env/" @@ -1379,6 +1415,8 @@ def test_base_url_env(self) -> None: ) assert str(client.base_url).startswith("http://localhost:5003") + await client.close() + @pytest.mark.parametrize( "client", [ @@ -1394,7 +1432,7 @@ def test_base_url_env(self) -> None: ], ids=["standard", "custom http client"], ) - def test_base_url_trailing_slash(self, client: AsyncAgentex) -> None: + async def test_base_url_trailing_slash(self, client: AsyncAgentex) -> None: request = client._build_request( FinalRequestOptions( method="post", @@ -1403,6 +1441,7 @@ def test_base_url_trailing_slash(self, client: AsyncAgentex) -> None: ), ) assert request.url == "http://localhost:5000/custom/path/foo" + await client.close() @pytest.mark.parametrize( "client", @@ -1419,7 +1458,7 @@ def test_base_url_trailing_slash(self, client: AsyncAgentex) -> None: ], ids=["standard", "custom http client"], ) - def test_base_url_no_trailing_slash(self, client: AsyncAgentex) -> None: + async def test_base_url_no_trailing_slash(self, client: AsyncAgentex) -> None: request = client._build_request( FinalRequestOptions( method="post", @@ -1428,6 +1467,7 @@ def test_base_url_no_trailing_slash(self, client: AsyncAgentex) -> None: ), ) assert request.url == "http://localhost:5000/custom/path/foo" + await client.close() @pytest.mark.parametrize( "client", @@ -1444,7 +1484,7 @@ def test_base_url_no_trailing_slash(self, client: AsyncAgentex) -> None: ], ids=["standard", "custom http client"], ) - def test_absolute_request_url(self, client: AsyncAgentex) -> None: + async def test_absolute_request_url(self, client: AsyncAgentex) -> None: request = client._build_request( FinalRequestOptions( method="post", @@ -1453,37 +1493,37 @@ def test_absolute_request_url(self, client: AsyncAgentex) -> None: ), ) assert request.url == "https://myapi.com/foo" + await client.close() async def test_copied_client_does_not_close_http(self) -> None: - client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) - assert not client.is_closed() + test_client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + assert not test_client.is_closed() - copied = client.copy() - assert copied is not client + copied = test_client.copy() + assert copied is not test_client del copied await asyncio.sleep(0.2) - assert not client.is_closed() + assert not test_client.is_closed() async def test_client_context_manager(self) -> None: - client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) - async with client as c2: - assert c2 is client + test_client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) + async with test_client as c2: + assert c2 is test_client assert not c2.is_closed() - assert not client.is_closed() - assert client.is_closed() + assert not test_client.is_closed() + assert test_client.is_closed() @pytest.mark.respx(base_url=base_url) - @pytest.mark.asyncio - async def test_client_response_validation_error(self, respx_mock: MockRouter) -> None: + async def test_client_response_validation_error(self, respx_mock: MockRouter, async_client: AsyncAgentex) -> None: class Model(BaseModel): foo: str respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": {"invalid": True}})) with pytest.raises(APIResponseValidationError) as exc: - await self.client.get("/foo", cast_to=Model) + await async_client.get("/foo", cast_to=Model) assert isinstance(exc.value.__cause__, ValidationError) @@ -1494,7 +1534,6 @@ async def test_client_max_retries_validation(self) -> None: ) @pytest.mark.respx(base_url=base_url) - @pytest.mark.asyncio async def test_received_text_for_expected_json(self, respx_mock: MockRouter) -> None: class Model(BaseModel): name: str @@ -1506,11 +1545,14 @@ class Model(BaseModel): with pytest.raises(APIResponseValidationError): await strict_client.get("/foo", cast_to=Model) - client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=False) + non_strict_client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=False) - response = await client.get("/foo", cast_to=Model) + response = await non_strict_client.get("/foo", cast_to=Model) assert isinstance(response, str) # type: ignore[unreachable] + await strict_client.close() + await non_strict_client.close() + @pytest.mark.parametrize( "remaining_retries,retry_after,timeout", [ @@ -1533,13 +1575,12 @@ class Model(BaseModel): ], ) @mock.patch("time.time", mock.MagicMock(return_value=1696004797)) - @pytest.mark.asyncio - async def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str, timeout: float) -> None: - client = AsyncAgentex(base_url=base_url, api_key=api_key, _strict_response_validation=True) - + async def test_parse_retry_after_header( + self, remaining_retries: int, retry_after: str, timeout: float, async_client: AsyncAgentex + ) -> None: headers = httpx.Headers({"retry-after": retry_after}) options = FinalRequestOptions(method="get", url="/foo", max_retries=3) - calculated = client._calculate_retry_timeout(remaining_retries, options, headers) + calculated = async_client._calculate_retry_timeout(remaining_retries, options, headers) assert calculated == pytest.approx(timeout, 0.5 * 0.875) # pyright: ignore[reportUnknownMemberType] @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @@ -1552,7 +1593,7 @@ async def test_retrying_timeout_errors_doesnt_leak( with pytest.raises(APITimeoutError): await async_client.tasks.with_streaming_response.list().__aenter__() - assert _get_open_connections(self.client) == 0 + assert _get_open_connections(async_client) == 0 @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) @@ -1561,12 +1602,11 @@ async def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, with pytest.raises(APIStatusError): await async_client.tasks.with_streaming_response.list().__aenter__() - assert _get_open_connections(self.client) == 0 + assert _get_open_connections(async_client) == 0 @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) - @pytest.mark.asyncio @pytest.mark.parametrize("failure_mode", ["status", "exception"]) async def test_retries_taken( self, @@ -1598,7 +1638,6 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) - @pytest.mark.asyncio async def test_omit_retry_count_header( self, async_client: AsyncAgentex, failures_before_success: int, respx_mock: MockRouter ) -> None: @@ -1622,7 +1661,6 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) @mock.patch("agentex._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout) @pytest.mark.respx(base_url=base_url) - @pytest.mark.asyncio async def test_overwrite_retry_count_header( self, async_client: AsyncAgentex, failures_before_success: int, respx_mock: MockRouter ) -> None: @@ -1670,26 +1708,26 @@ async def test_default_client_creation(self) -> None: ) @pytest.mark.respx(base_url=base_url) - async def test_follow_redirects(self, respx_mock: MockRouter) -> None: + async def test_follow_redirects(self, respx_mock: MockRouter, async_client: AsyncAgentex) -> None: # Test that the default follow_redirects=True allows following redirects respx_mock.post("/redirect").mock( return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"}) ) respx_mock.get("/redirected").mock(return_value=httpx.Response(200, json={"status": "ok"})) - response = await self.client.post("/redirect", body={"key": "value"}, cast_to=httpx.Response) + response = await async_client.post("/redirect", body={"key": "value"}, cast_to=httpx.Response) assert response.status_code == 200 assert response.json() == {"status": "ok"} @pytest.mark.respx(base_url=base_url) - async def test_follow_redirects_disabled(self, respx_mock: MockRouter) -> None: + async def test_follow_redirects_disabled(self, respx_mock: MockRouter, async_client: AsyncAgentex) -> None: # Test that follow_redirects=False prevents following redirects respx_mock.post("/redirect").mock( return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"}) ) with pytest.raises(APIStatusError) as exc_info: - await self.client.post( + await async_client.post( "/redirect", body={"key": "value"}, options={"follow_redirects": False}, cast_to=httpx.Response ) From 2ceef54eb56d4735edc684d72f78f1e254e92c67 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 30 Oct 2025 12:23:09 +0000 Subject: [PATCH 0648/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 85e105c5002d1cdee7a5837c6dd334b9813f66a5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 30 Oct 2025 14:22:45 +0000 Subject: [PATCH 0649/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 507c2add..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 6053ab330c2f95ed89a972377461413786501390 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 30 Oct 2025 15:22:48 +0000 Subject: [PATCH 0650/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From a631adb2a803404bd111b0928464401f1e3a6a97 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 30 Oct 2025 16:22:50 +0000 Subject: [PATCH 0651/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 507c2add..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From bef8f0ff2dd302a57dbaeaf2b6014c46f5f48a8c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 30 Oct 2025 17:22:46 +0000 Subject: [PATCH 0652/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From f9afac8a0f0999ff0e6d6478daf41242a6843f48 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 30 Oct 2025 18:22:44 +0000 Subject: [PATCH 0653/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 507c2add..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From b9035707de56ee7d35dcc708c8ac533f0d4893e9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 30 Oct 2025 19:22:42 +0000 Subject: [PATCH 0654/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 306baf6fa70a2f40dedd3a2349550054847dcb33 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 30 Oct 2025 20:22:50 +0000 Subject: [PATCH 0655/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 507c2add..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 7da2032145d53607599023ee0601e047215a3a74 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 30 Oct 2025 21:22:42 +0000 Subject: [PATCH 0656/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 6aae856ed2ed33ae672972a049e566c51c7aac03 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 30 Oct 2025 22:22:50 +0000 Subject: [PATCH 0657/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 507c2add..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 4688439ebc0e6d8cff2392490deb68eb20fbada1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 30 Oct 2025 23:22:41 +0000 Subject: [PATCH 0658/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 4255fdd9f9c879b115e84caff36d3c8a723f5533 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 03:22:48 +0000 Subject: [PATCH 0659/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 507c2add..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 2604b92e80bd72bf4806e490c7595dcdac9d0091 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 07:22:42 +0000 Subject: [PATCH 0660/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 2a4d8a26f39296d800271f3f3223762dd78dec57 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 10:22:45 +0000 Subject: [PATCH 0661/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 507c2add..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From f127ef16bb03e163273b5097df94d11cef586949 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 11:22:42 +0000 Subject: [PATCH 0662/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From b56447d0a82a3b9388d4d2a63ddd0d9027f64f76 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 12:22:42 +0000 Subject: [PATCH 0663/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 507c2add..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From ff1f5c3925b987bbc3a7486b6c48195d0e2769a6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 13:22:43 +0000 Subject: [PATCH 0664/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 436ee438b15d17317e7a1640cfcf1e814fd6c77a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 14:22:40 +0000 Subject: [PATCH 0665/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 507c2add..e50822b4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 51a4d9405c9799ed8db10dd5bfc744e54f4af018 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 16:22:51 +0000 Subject: [PATCH 0666/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index e50822b4..507c2add 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 6481ea6b42040f435dedcb00a98f35f8 From 4d4c07bfd2c6f9fb802bd70cd6e429aaa62e322f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 18:24:03 +0000 Subject: [PATCH 0667/1108] feat(api): manual updates --- .github/workflows/publish-pypi.yml | 2 +- .github/workflows/release-doctor.yml | 2 +- .stats.yml | 6 +++--- CONTRIBUTING.md | 4 ++-- README.md | 6 +++--- pyproject.toml | 6 +++--- src/agentex/resources/agents.py | 8 ++++---- src/agentex/resources/events.py | 8 ++++---- src/agentex/resources/messages/batch.py | 8 ++++---- src/agentex/resources/messages/messages.py | 8 ++++---- src/agentex/resources/spans.py | 8 ++++---- src/agentex/resources/states.py | 8 ++++---- src/agentex/resources/tasks.py | 8 ++++---- src/agentex/resources/tracker.py | 8 ++++---- 14 files changed, 45 insertions(+), 45 deletions(-) diff --git a/.github/workflows/publish-pypi.yml b/.github/workflows/publish-pypi.yml index 7e8ac3bd..2f6d7779 100644 --- a/.github/workflows/publish-pypi.yml +++ b/.github/workflows/publish-pypi.yml @@ -1,6 +1,6 @@ # This workflow is triggered when a GitHub release is created. # It can also be run manually to re-publish to PyPI in case it failed for some reason. -# You can run this workflow by navigating to https://www.github.com/scaleapi/agentex-python/actions/workflows/publish-pypi.yml +# You can run this workflow by navigating to https://www.github.com/scaleapi/scale-agentex-python/actions/workflows/publish-pypi.yml name: Publish PyPI on: workflow_dispatch: diff --git a/.github/workflows/release-doctor.yml b/.github/workflows/release-doctor.yml index 0521b7f6..321914dd 100644 --- a/.github/workflows/release-doctor.yml +++ b/.github/workflows/release-doctor.yml @@ -9,7 +9,7 @@ jobs: release_doctor: name: release doctor runs-on: ubuntu-latest - if: github.repository == 'scaleapi/agentex-python' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch' || startsWith(github.head_ref, 'release-please') || github.head_ref == 'next') + if: github.repository == 'scaleapi/scale-agentex-python' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch' || startsWith(github.head_ref, 'release-please') || github.head_ref == 'next') steps: - uses: actions/checkout@v4 diff --git a/.stats.yml b/.stats.yml index 507c2add..c4e027b5 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 -config_hash: 6481ea6b42040f435dedcb00a98f35f8 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 +config_hash: bdc6acf8b97fe32a42ab99c3319226cc diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 305c811e..67ab9a5d 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -62,7 +62,7 @@ If you’d like to use the repository from source, you can either install from g To install via git: ```sh -$ pip install git+ssh://git@github.com/scaleapi/agentex-python.git +$ pip install git+ssh://git@github.com/scaleapi/scale-agentex-python.git ``` Alternatively, you can build from source and install the wheel file: @@ -120,7 +120,7 @@ the changes aren't made through the automated pipeline, you may want to make rel ### Publish with a GitHub workflow -You can release to package managers by using [the `Publish PyPI` GitHub action](https://www.github.com/scaleapi/agentex-python/actions/workflows/publish-pypi.yml). This requires a setup organization or repository secret to be set up. +You can release to package managers by using [the `Publish PyPI` GitHub action](https://www.github.com/scaleapi/scale-agentex-python/actions/workflows/publish-pypi.yml). This requires a setup organization or repository secret to be set up. ### Publish manually diff --git a/README.md b/README.md index e8b874ff..777bdddd 100644 --- a/README.md +++ b/README.md @@ -236,9 +236,9 @@ task = response.parse() # get the object that `tasks.list()` would have returne print(task) ``` -These methods return an [`APIResponse`](https://github.com/scaleapi/agentex-python/tree/main/src/agentex/_response.py) object. +These methods return an [`APIResponse`](https://github.com/scaleapi/scale-agentex-python/tree/main/src/agentex/_response.py) object. -The async client returns an [`AsyncAPIResponse`](https://github.com/scaleapi/agentex-python/tree/main/src/agentex/_response.py) with the same structure, the only difference being `await`able methods for reading the response content. +The async client returns an [`AsyncAPIResponse`](https://github.com/scaleapi/scale-agentex-python/tree/main/src/agentex/_response.py) with the same structure, the only difference being `await`able methods for reading the response content. #### `.with_streaming_response` @@ -342,7 +342,7 @@ This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) con We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience. -We are keen for your feedback; please open an [issue](https://www.github.com/scaleapi/agentex-python/issues) with questions, bugs, or suggestions. +We are keen for your feedback; please open an [issue](https://www.github.com/scaleapi/scale-agentex-python/issues) with questions, bugs, or suggestions. ### Determining the installed version diff --git a/pyproject.toml b/pyproject.toml index 2926a8fb..ccb315fc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -35,8 +35,8 @@ classifiers = [ ] [project.urls] -Homepage = "https://github.com/scaleapi/agentex-python" -Repository = "https://github.com/scaleapi/agentex-python" +Homepage = "https://github.com/scaleapi/scale-agentex-python" +Repository = "https://github.com/scaleapi/scale-agentex-python" [project.optional-dependencies] aiohttp = ["aiohttp", "httpx_aiohttp>=0.1.9"] @@ -124,7 +124,7 @@ path = "README.md" [[tool.hatch.metadata.hooks.fancy-pypi-readme.substitutions]] # replace relative links with absolute links pattern = '\[(.+?)\]\(((?!https?://)\S+?)\)' -replacement = '[\1](https://github.com/scaleapi/agentex-python/tree/main/\g<2>)' +replacement = '[\1](https://github.com/scaleapi/scale-agentex-python/tree/main/\g<2>)' [tool.pytest.ini_options] testpaths = ["tests"] diff --git a/src/agentex/resources/agents.py b/src/agentex/resources/agents.py index 71297bb7..06124820 100644 --- a/src/agentex/resources/agents.py +++ b/src/agentex/resources/agents.py @@ -34,7 +34,7 @@ def with_raw_response(self) -> AgentsResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return AgentsResourceWithRawResponse(self) @@ -43,7 +43,7 @@ def with_streaming_response(self) -> AgentsResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return AgentsResourceWithStreamingResponse(self) @@ -333,7 +333,7 @@ def with_raw_response(self) -> AsyncAgentsResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return AsyncAgentsResourceWithRawResponse(self) @@ -342,7 +342,7 @@ def with_streaming_response(self) -> AsyncAgentsResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return AsyncAgentsResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/events.py b/src/agentex/resources/events.py index f6740590..64ac6326 100644 --- a/src/agentex/resources/events.py +++ b/src/agentex/resources/events.py @@ -31,7 +31,7 @@ def with_raw_response(self) -> EventsResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return EventsResourceWithRawResponse(self) @@ -40,7 +40,7 @@ def with_streaming_response(self) -> EventsResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return EventsResourceWithStreamingResponse(self) @@ -142,7 +142,7 @@ def with_raw_response(self) -> AsyncEventsResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return AsyncEventsResourceWithRawResponse(self) @@ -151,7 +151,7 @@ def with_streaming_response(self) -> AsyncEventsResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return AsyncEventsResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/messages/batch.py b/src/agentex/resources/messages/batch.py index f6c06ced..f5e61a49 100644 --- a/src/agentex/resources/messages/batch.py +++ b/src/agentex/resources/messages/batch.py @@ -32,7 +32,7 @@ def with_raw_response(self) -> BatchResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return BatchResourceWithRawResponse(self) @@ -41,7 +41,7 @@ def with_streaming_response(self) -> BatchResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return BatchResourceWithStreamingResponse(self) @@ -131,7 +131,7 @@ def with_raw_response(self) -> AsyncBatchResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return AsyncBatchResourceWithRawResponse(self) @@ -140,7 +140,7 @@ def with_streaming_response(self) -> AsyncBatchResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return AsyncBatchResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index 08ebbbd1..84537bca 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -45,7 +45,7 @@ def with_raw_response(self) -> MessagesResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return MessagesResourceWithRawResponse(self) @@ -54,7 +54,7 @@ def with_streaming_response(self) -> MessagesResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return MessagesResourceWithStreamingResponse(self) @@ -234,7 +234,7 @@ def with_raw_response(self) -> AsyncMessagesResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return AsyncMessagesResourceWithRawResponse(self) @@ -243,7 +243,7 @@ def with_streaming_response(self) -> AsyncMessagesResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return AsyncMessagesResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/spans.py b/src/agentex/resources/spans.py index b896c74a..427ae079 100644 --- a/src/agentex/resources/spans.py +++ b/src/agentex/resources/spans.py @@ -32,7 +32,7 @@ def with_raw_response(self) -> SpansResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return SpansResourceWithRawResponse(self) @@ -41,7 +41,7 @@ def with_streaming_response(self) -> SpansResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return SpansResourceWithStreamingResponse(self) @@ -271,7 +271,7 @@ def with_raw_response(self) -> AsyncSpansResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return AsyncSpansResourceWithRawResponse(self) @@ -280,7 +280,7 @@ def with_streaming_response(self) -> AsyncSpansResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return AsyncSpansResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/states.py b/src/agentex/resources/states.py index d98c2ddc..8642317e 100644 --- a/src/agentex/resources/states.py +++ b/src/agentex/resources/states.py @@ -31,7 +31,7 @@ def with_raw_response(self) -> StatesResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return StatesResourceWithRawResponse(self) @@ -40,7 +40,7 @@ def with_streaming_response(self) -> StatesResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return StatesResourceWithStreamingResponse(self) @@ -257,7 +257,7 @@ def with_raw_response(self) -> AsyncStatesResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return AsyncStatesResourceWithRawResponse(self) @@ -266,7 +266,7 @@ def with_streaming_response(self) -> AsyncStatesResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return AsyncStatesResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/tasks.py b/src/agentex/resources/tasks.py index 33a4648d..a941c42b 100644 --- a/src/agentex/resources/tasks.py +++ b/src/agentex/resources/tasks.py @@ -35,7 +35,7 @@ def with_raw_response(self) -> TasksResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return TasksResourceWithRawResponse(self) @@ -44,7 +44,7 @@ def with_streaming_response(self) -> TasksResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return TasksResourceWithStreamingResponse(self) @@ -318,7 +318,7 @@ def with_raw_response(self) -> AsyncTasksResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return AsyncTasksResourceWithRawResponse(self) @@ -327,7 +327,7 @@ def with_streaming_response(self) -> AsyncTasksResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return AsyncTasksResourceWithStreamingResponse(self) diff --git a/src/agentex/resources/tracker.py b/src/agentex/resources/tracker.py index 11bec36f..516e958f 100644 --- a/src/agentex/resources/tracker.py +++ b/src/agentex/resources/tracker.py @@ -31,7 +31,7 @@ def with_raw_response(self) -> TrackerResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return TrackerResourceWithRawResponse(self) @@ -40,7 +40,7 @@ def with_streaming_response(self) -> TrackerResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return TrackerResourceWithStreamingResponse(self) @@ -189,7 +189,7 @@ def with_raw_response(self) -> AsyncTrackerResourceWithRawResponse: This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. - For more information, see https://www.github.com/scaleapi/agentex-python#accessing-raw-response-data-eg-headers + For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers """ return AsyncTrackerResourceWithRawResponse(self) @@ -198,7 +198,7 @@ def with_streaming_response(self) -> AsyncTrackerResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. - For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response + For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response """ return AsyncTrackerResourceWithStreamingResponse(self) From c2c53a4ab7793e9016bf4e9067f6880a57d40c9c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 18:34:11 +0000 Subject: [PATCH 0668/1108] codegen metadata --- .stats.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.stats.yml b/.stats.yml index c4e027b5..5f495181 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml openapi_spec_hash: bca5c04d823694c87417dae188480291 -config_hash: bdc6acf8b97fe32a42ab99c3319226cc +config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 44143ac117b4c9bf721a586a224abb1ebca0642b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 18:49:41 +0000 Subject: [PATCH 0669/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5f495181..23c0d3e9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 856cbde7e8b4f6fbcc63d73bfb2098b1e87ea8aa Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 19:22:49 +0000 Subject: [PATCH 0670/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 23c0d3e9..5f495181 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From a85a5c76858b74514a662d04a70a2b8eba82f511 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 21:22:49 +0000 Subject: [PATCH 0671/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5f495181..23c0d3e9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 18836d935e13977850d560729208d936ebbdd679 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 22:13:09 +0000 Subject: [PATCH 0672/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 2aca35ae..383dd5a3 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.5.0" + ".": "0.5.2" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index ccb315fc..5002f79c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.5.0" +version = "0.5.2" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 6d776a78..4729ac14 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.5.0" # x-release-please-version +__version__ = "0.5.2" # x-release-please-version From fd718833d311f15224427734aedabfe5cc464acd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 22:22:33 +0000 Subject: [PATCH 0673/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 23c0d3e9..5f495181 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 9b570128516840f7934fc9f073085b8529a7a919 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 31 Oct 2025 22:45:04 +0000 Subject: [PATCH 0674/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 383dd5a3..6bc1697d 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.5.2" + ".": "0.5.3" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 5002f79c..6fc0bb16 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.5.2" +version = "0.5.3" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 4729ac14..501d1b1e 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.5.2" # x-release-please-version +__version__ = "0.5.3" # x-release-please-version From 67f54677a82ee3554ea126f75d4d67c8d812bbb9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 3 Nov 2025 16:10:30 +0000 Subject: [PATCH 0675/1108] chore(internal): grammar fix (it's -> its) --- src/agentex/_utils/_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/agentex/_utils/_utils.py b/src/agentex/_utils/_utils.py index 50d59269..eec7f4a1 100644 --- a/src/agentex/_utils/_utils.py +++ b/src/agentex/_utils/_utils.py @@ -133,7 +133,7 @@ def is_given(obj: _T | NotGiven | Omit) -> TypeGuard[_T]: # Type safe methods for narrowing types with TypeVars. # The default narrowing for isinstance(obj, dict) is dict[unknown, unknown], # however this cause Pyright to rightfully report errors. As we know we don't -# care about the contained types we can safely use `object` in it's place. +# care about the contained types we can safely use `object` in its place. # # There are two separate functions defined, `is_*` and `is_*_t` for different use cases. # `is_*` is for when you're dealing with an unknown input From 4bf8b8f3bb61beb3d44ee894177a5be4dd4f2212 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 3 Nov 2025 18:22:42 +0000 Subject: [PATCH 0676/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5f495181..23c0d3e9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From ef8841d274aaf8b427ea9f6add5ef96af79bc6a7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 3 Nov 2025 19:22:31 +0000 Subject: [PATCH 0677/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 23c0d3e9..5f495181 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml +openapi_spec_hash: bca5c04d823694c87417dae188480291 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From ad54bfe125b06e27728253bf5538078258a24df5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 3 Nov 2025 22:22:42 +0000 Subject: [PATCH 0678/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5f495181..23c0d3e9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml -openapi_spec_hash: bca5c04d823694c87417dae188480291 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml +openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From f63deabc1f7eb60d06f6487ec43edd99f8b01a10 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 4 Nov 2025 02:22:29 +0000 Subject: [PATCH 0679/1108] feat(api): api update --- .stats.yml | 4 ++-- src/agentex/types/acp_type.py | 2 +- src/agentex/types/agent.py | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.stats.yml b/.stats.yml index 23c0d3e9..d93f3421 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2ba36d013a2829080b1003d4fecc30e89447db013f87491dd4d76f728d200b85.yml -openapi_spec_hash: ff4de1c4bd38d4ff35bcf30755f0d870 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-0556db8b729c565a582332ce7e175b6b0d95e0d56addd543673a9e52ebd5d58b.yml +openapi_spec_hash: 8c0f9039f66b0017b2dea4574efefed4 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 diff --git a/src/agentex/types/acp_type.py b/src/agentex/types/acp_type.py index ec86ddf5..8b70a292 100644 --- a/src/agentex/types/acp_type.py +++ b/src/agentex/types/acp_type.py @@ -4,4 +4,4 @@ __all__ = ["AcpType"] -AcpType: TypeAlias = Literal["sync", "agentic"] +AcpType: TypeAlias = Literal["sync", "async", "agentic"] diff --git a/src/agentex/types/agent.py b/src/agentex/types/agent.py index 731332ab..19633b61 100644 --- a/src/agentex/types/agent.py +++ b/src/agentex/types/agent.py @@ -15,7 +15,7 @@ class Agent(BaseModel): """The unique identifier of the agent.""" acp_type: AcpType - """The type of the ACP Server (Either sync or agentic)""" + """The type of the ACP Server (Either sync or async)""" created_at: datetime """The timestamp when the agent was created""" From ddb5632a54010aa7a7375fabf517aa15f7b66fbd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 4 Nov 2025 04:22:29 +0000 Subject: [PATCH 0680/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index d93f3421..bfd09cb6 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-0556db8b729c565a582332ce7e175b6b0d95e0d56addd543673a9e52ebd5d58b.yml -openapi_spec_hash: 8c0f9039f66b0017b2dea4574efefed4 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c1368f8609bf74b5f5f6439d2e34e5f52aa9a391c2f46fdb36682a2960daaf25.yml +openapi_spec_hash: c7a8cab4aab71cb7e2414111350519e7 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 1b96ab12c9cb5d9190b965c97fd8324318b3a0eb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 4 Nov 2025 06:22:29 +0000 Subject: [PATCH 0681/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index bfd09cb6..d93f3421 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c1368f8609bf74b5f5f6439d2e34e5f52aa9a391c2f46fdb36682a2960daaf25.yml -openapi_spec_hash: c7a8cab4aab71cb7e2414111350519e7 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-0556db8b729c565a582332ce7e175b6b0d95e0d56addd543673a9e52ebd5d58b.yml +openapi_spec_hash: 8c0f9039f66b0017b2dea4574efefed4 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From a90a266442416bd45465e0bc25dd973650ee2e8f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 4 Nov 2025 08:22:28 +0000 Subject: [PATCH 0682/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index d93f3421..bfd09cb6 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-0556db8b729c565a582332ce7e175b6b0d95e0d56addd543673a9e52ebd5d58b.yml -openapi_spec_hash: 8c0f9039f66b0017b2dea4574efefed4 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c1368f8609bf74b5f5f6439d2e34e5f52aa9a391c2f46fdb36682a2960daaf25.yml +openapi_spec_hash: c7a8cab4aab71cb7e2414111350519e7 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 7baf364f4ce71ebd4e557b3d87642a3f75c59021 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 4 Nov 2025 10:22:31 +0000 Subject: [PATCH 0683/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index bfd09cb6..d93f3421 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c1368f8609bf74b5f5f6439d2e34e5f52aa9a391c2f46fdb36682a2960daaf25.yml -openapi_spec_hash: c7a8cab4aab71cb7e2414111350519e7 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-0556db8b729c565a582332ce7e175b6b0d95e0d56addd543673a9e52ebd5d58b.yml +openapi_spec_hash: 8c0f9039f66b0017b2dea4574efefed4 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 5284e3847cf81fcbab4ccd92f6bf05c4e7204fd7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 4 Nov 2025 14:22:42 +0000 Subject: [PATCH 0684/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index d93f3421..bfd09cb6 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-0556db8b729c565a582332ce7e175b6b0d95e0d56addd543673a9e52ebd5d58b.yml -openapi_spec_hash: 8c0f9039f66b0017b2dea4574efefed4 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c1368f8609bf74b5f5f6439d2e34e5f52aa9a391c2f46fdb36682a2960daaf25.yml +openapi_spec_hash: c7a8cab4aab71cb7e2414111350519e7 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 9dfb1476170e1ccfdc08596209a0bd554df722d2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 4 Nov 2025 15:22:49 +0000 Subject: [PATCH 0685/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index bfd09cb6..d93f3421 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c1368f8609bf74b5f5f6439d2e34e5f52aa9a391c2f46fdb36682a2960daaf25.yml -openapi_spec_hash: c7a8cab4aab71cb7e2414111350519e7 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-0556db8b729c565a582332ce7e175b6b0d95e0d56addd543673a9e52ebd5d58b.yml +openapi_spec_hash: 8c0f9039f66b0017b2dea4574efefed4 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 806aca6721a2ff466ed57130b592a948ec7a0d8f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 4 Nov 2025 16:22:43 +0000 Subject: [PATCH 0686/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index d93f3421..bfd09cb6 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-0556db8b729c565a582332ce7e175b6b0d95e0d56addd543673a9e52ebd5d58b.yml -openapi_spec_hash: 8c0f9039f66b0017b2dea4574efefed4 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c1368f8609bf74b5f5f6439d2e34e5f52aa9a391c2f46fdb36682a2960daaf25.yml +openapi_spec_hash: c7a8cab4aab71cb7e2414111350519e7 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From fb2a79794f36c57fc0b6704795bbaf80ab8ae853 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 4 Nov 2025 17:22:48 +0000 Subject: [PATCH 0687/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index bfd09cb6..d93f3421 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c1368f8609bf74b5f5f6439d2e34e5f52aa9a391c2f46fdb36682a2960daaf25.yml -openapi_spec_hash: c7a8cab4aab71cb7e2414111350519e7 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-0556db8b729c565a582332ce7e175b6b0d95e0d56addd543673a9e52ebd5d58b.yml +openapi_spec_hash: 8c0f9039f66b0017b2dea4574efefed4 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From edfb0790f9b242d8f9da0c2ff1b8d9864040d5ff Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 4 Nov 2025 18:25:35 +0000 Subject: [PATCH 0688/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 6bc1697d..4208b5cb 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.5.3" + ".": "0.6.0" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 6fc0bb16..512ca80e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.5.3" +version = "0.6.0" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 501d1b1e..d98070dd 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.5.3" # x-release-please-version +__version__ = "0.6.0" # x-release-please-version From f7c7c812d7bed485779395c93f3f9f43a0b5969e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 4 Nov 2025 19:22:38 +0000 Subject: [PATCH 0689/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index d93f3421..bfd09cb6 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-0556db8b729c565a582332ce7e175b6b0d95e0d56addd543673a9e52ebd5d58b.yml -openapi_spec_hash: 8c0f9039f66b0017b2dea4574efefed4 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c1368f8609bf74b5f5f6439d2e34e5f52aa9a391c2f46fdb36682a2960daaf25.yml +openapi_spec_hash: c7a8cab4aab71cb7e2414111350519e7 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From f526dbc61764f913f4bdc8d65b2b324ae6495204 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 5 Nov 2025 00:22:43 +0000 Subject: [PATCH 0690/1108] feat(api): api update --- .stats.yml | 4 ++-- src/agentex/types/agent.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.stats.yml b/.stats.yml index bfd09cb6..080a154c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c1368f8609bf74b5f5f6439d2e34e5f52aa9a391c2f46fdb36682a2960daaf25.yml -openapi_spec_hash: c7a8cab4aab71cb7e2414111350519e7 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-5ba3790d74703c432197dccf5f03b4f4e40ab6a72dedd7abaea76ec720339148.yml +openapi_spec_hash: a8ffcb25135faa13b5d180f6ee1f920d config_hash: 0197f86ba1a4b1b5ce813d0e62138588 diff --git a/src/agentex/types/agent.py b/src/agentex/types/agent.py index 19633b61..fe1eaa3e 100644 --- a/src/agentex/types/agent.py +++ b/src/agentex/types/agent.py @@ -35,7 +35,7 @@ class Agent(BaseModel): registration_metadata: Optional[Dict[str, object]] = None """The metadata for the agent's registration.""" - status: Optional[Literal["Ready", "Failed", "Unknown", "Deleted"]] = None + status: Optional[Literal["Ready", "Failed", "Unknown", "Deleted", "Unhealthy"]] = None """The status of the action, indicating if it's building, ready, failed, etc.""" status_reason: Optional[str] = None From 3d17920c0e83a846d646037d7c2d3dc80480d302 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 5 Nov 2025 01:22:47 +0000 Subject: [PATCH 0691/1108] feat(api): api update --- .stats.yml | 4 ++-- src/agentex/types/agent.py | 3 +++ 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 080a154c..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-5ba3790d74703c432197dccf5f03b4f4e40ab6a72dedd7abaea76ec720339148.yml -openapi_spec_hash: a8ffcb25135faa13b5d180f6ee1f920d +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 diff --git a/src/agentex/types/agent.py b/src/agentex/types/agent.py index fe1eaa3e..7828822c 100644 --- a/src/agentex/types/agent.py +++ b/src/agentex/types/agent.py @@ -29,6 +29,9 @@ class Agent(BaseModel): updated_at: datetime """The timestamp when the agent was last updated""" + agent_input_type: Optional[Literal["text", "json"]] = None + """The type of input the agent expects.""" + registered_at: Optional[datetime] = None """The timestamp when the agent was last registered""" From e15dfce91375073a0a4b83ecfd6374f508235199 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 5 Nov 2025 03:22:39 +0000 Subject: [PATCH 0692/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 85b955785ef5de3d0d6062efe0de4e25e70ae286 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 5 Nov 2025 04:29:30 +0000 Subject: [PATCH 0693/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 4208b5cb..ac031714 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.6.0" + ".": "0.6.1" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 512ca80e..bc6c2106 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.6.0" +version = "0.6.1" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index d98070dd..c772a2ab 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.6.0" # x-release-please-version +__version__ = "0.6.1" # x-release-please-version From 5d2898cd694037ca3b9046cd75ab69a53e6a38be Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 5 Nov 2025 06:22:43 +0000 Subject: [PATCH 0694/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 44544fc2344af287be437c1115aca10461ec1545 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 5 Nov 2025 07:22:45 +0000 Subject: [PATCH 0695/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From faeeaa8dcc455d427f2ee0ccd33494a64fd4347b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 5 Nov 2025 10:22:45 +0000 Subject: [PATCH 0696/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 31f1db2f6531da8bcc970034ed48363976ab4a44 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 5 Nov 2025 12:22:42 +0000 Subject: [PATCH 0697/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 8b94c53463198b32b421538b9ec3240e3ac1d2ab Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 5 Nov 2025 14:22:37 +0000 Subject: [PATCH 0698/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 9f5915bccc7492bbd9095840993fa840fe5b5635 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 5 Nov 2025 16:00:25 +0000 Subject: [PATCH 0699/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index ac031714..e3778b2c 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.6.1" + ".": "0.6.2" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index bc6c2106..b499535d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.6.1" +version = "0.6.2" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index c772a2ab..4caa2ac3 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.6.1" # x-release-please-version +__version__ = "0.6.2" # x-release-please-version From 7956328a3cbda5de9013cf544bbe46673fe1c793 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 5 Nov 2025 17:22:37 +0000 Subject: [PATCH 0700/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 8304696a17ff35b0b4846f9c97a31ee4c628559b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 5 Nov 2025 20:22:41 +0000 Subject: [PATCH 0701/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e112d3ccba88207afecb23238bd192d75df286e9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 5 Nov 2025 21:22:42 +0000 Subject: [PATCH 0702/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From dc5ec21a7966cc7002be607831f4ae9509adfe8d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 6 Nov 2025 00:22:43 +0000 Subject: [PATCH 0703/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 5462ad1468ead43670ce04b6dc9e7e28f48c0098 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 6 Nov 2025 03:22:40 +0000 Subject: [PATCH 0704/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 8bd87bcad9857a8d0dce307be3002672499f2fd1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 6 Nov 2025 06:22:46 +0000 Subject: [PATCH 0705/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 2f41e5b746809aaf2d0842ac26afe2842dbb1dc0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 6 Nov 2025 07:22:45 +0000 Subject: [PATCH 0706/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c9c39b123a648d693d0bbd72b6beec7dc77fd295 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 6 Nov 2025 08:22:49 +0000 Subject: [PATCH 0707/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e54709286b59391b1279f54dd85a176bb34a486b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 6 Nov 2025 11:22:51 +0000 Subject: [PATCH 0708/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 07d047a4531def32f4b9f0f8d3dad3d46fa3c372 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 6 Nov 2025 12:22:56 +0000 Subject: [PATCH 0709/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 7c4aca9cb331dfdec52ebd3e31a057056226305b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 6 Nov 2025 13:22:50 +0000 Subject: [PATCH 0710/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 6ce3189f0276a251bf182ad9de083a4bde915ce4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 6 Nov 2025 18:34:27 +0000 Subject: [PATCH 0711/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index e3778b2c..5c87ad82 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.6.2" + ".": "0.6.3" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index b499535d..65a5c3fa 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.6.2" +version = "0.6.3" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 4caa2ac3..a77097af 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.6.2" # x-release-please-version +__version__ = "0.6.3" # x-release-please-version From 66f909dff8c95e52fc880ca89eda034324c6f247 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 6 Nov 2025 19:22:47 +0000 Subject: [PATCH 0712/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 456f784d0afa0a84e520f118073c35c22118b542 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 6 Nov 2025 21:22:45 +0000 Subject: [PATCH 0713/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 077433e2bf0b46fd775bff13881c5d1b02af06ce Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 6 Nov 2025 22:28:02 +0000 Subject: [PATCH 0714/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 5c87ad82..12aa8969 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.6.3" + ".": "0.6.4" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 65a5c3fa..69c86853 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.6.3" +version = "0.6.4" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index a77097af..aec3ecd8 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.6.3" # x-release-please-version +__version__ = "0.6.4" # x-release-please-version From 3a26616650529b97398d2d2c1c6a97728ab65bac Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 6 Nov 2025 23:55:04 +0000 Subject: [PATCH 0715/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 12aa8969..e90b36cc 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.6.4" + ".": "0.6.5" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 69c86853..31d0bc28 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.6.4" +version = "0.6.5" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index aec3ecd8..34669904 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.6.4" # x-release-please-version +__version__ = "0.6.5" # x-release-please-version From 5790b53a6fb76e7288951ff59570a8005b95ab5b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 7 Nov 2025 01:22:47 +0000 Subject: [PATCH 0716/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From eb000c9b755d9241334e34f41dee61d48ebf62e8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 7 Nov 2025 08:22:45 +0000 Subject: [PATCH 0717/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 8be2c4419261e0013fc45b6f673f569f9a72fe6d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 7 Nov 2025 09:22:43 +0000 Subject: [PATCH 0718/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 63b51fa4e4499d3c48f76f833354edf03b73ee3c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 7 Nov 2025 13:22:44 +0000 Subject: [PATCH 0719/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 439a4732aeb69dfb8e39ec48cc1877d2000406de Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 7 Nov 2025 15:22:44 +0000 Subject: [PATCH 0720/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e3ef0e565fb302c7713c2c7bc8293b571b4dfc75 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 7 Nov 2025 16:22:45 +0000 Subject: [PATCH 0721/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 0139b0b02fa373bcd17f73f5ffb0754e80ec09f6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 7 Nov 2025 18:23:27 +0000 Subject: [PATCH 0722/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 7f9128dd6fe79d53c0970c2f7ecb8a7c08f23efe Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 7 Nov 2025 21:22:46 +0000 Subject: [PATCH 0723/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 46a52bce8ae32b1532e1bc675ff3f3440194e38e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 7 Nov 2025 22:22:37 +0000 Subject: [PATCH 0724/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 9a20a6ee48ad5b48b2e8ba4fd4c99852f53aca4e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 8 Nov 2025 00:22:40 +0000 Subject: [PATCH 0725/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e131bdf3715cd9d2d91e94421d776a7351e6c521 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 8 Nov 2025 02:22:38 +0000 Subject: [PATCH 0726/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From fb68ce81a3a27968326faf3ed205568a0c65fa44 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 8 Nov 2025 06:22:38 +0000 Subject: [PATCH 0727/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From dca40dfebc4af427a39f97f95023c682abd087cc Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 8 Nov 2025 09:22:39 +0000 Subject: [PATCH 0728/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 0e3d5668c54d0afe39bdd79b61b58640c57a26b2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 8 Nov 2025 10:22:36 +0000 Subject: [PATCH 0729/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From ce3bed61c698dda5d53780de4a8b50cdd2cc4375 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 8 Nov 2025 12:22:39 +0000 Subject: [PATCH 0730/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 227ba910d9474f04887f5815d28eb53dc84773c3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 8 Nov 2025 20:22:40 +0000 Subject: [PATCH 0731/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 4825836ba048708680c7d1e9da9b15aca5b5c0e1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 8 Nov 2025 21:22:38 +0000 Subject: [PATCH 0732/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From f48fe013a4e035e07d7b839f99029fc78b11b835 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 8 Nov 2025 22:22:38 +0000 Subject: [PATCH 0733/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From b935f4833879c4e47508e0609e4caf7a9e7b4bb6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 9 Nov 2025 00:22:37 +0000 Subject: [PATCH 0734/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 6b5bbb1e4d7bcbebca3ff8623922a228b62670f5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 9 Nov 2025 01:22:39 +0000 Subject: [PATCH 0735/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From a6e7873bd9a9ed6f2640fabaa5c85525e2d06643 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 9 Nov 2025 03:22:52 +0000 Subject: [PATCH 0736/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 218a00965deca33b93578a232c2be14e58b27dbd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 9 Nov 2025 06:22:40 +0000 Subject: [PATCH 0737/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 8894102c81f87726087ccbb1a92f6e2738e527e3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 9 Nov 2025 07:22:37 +0000 Subject: [PATCH 0738/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From a1da9e84ba26e9b977e25648ccbc49ecbf483b5d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 9 Nov 2025 08:22:36 +0000 Subject: [PATCH 0739/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e363013777a728cde50fdad38abfa34780c7905c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 9 Nov 2025 14:22:40 +0000 Subject: [PATCH 0740/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 2409f357c08458c505984be8599342fde2976be4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 9 Nov 2025 22:22:38 +0000 Subject: [PATCH 0741/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 8fbb241c42430f53c1e5cf92405a413f73b15e33 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 10 Nov 2025 05:22:40 +0000 Subject: [PATCH 0742/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From ba8020181d2350fbf77271d30c6819acfd24aabb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 10 Nov 2025 07:22:38 +0000 Subject: [PATCH 0743/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From b146eb81fa77e46d2722a25cb2ff9b08442e3b88 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 10 Nov 2025 08:22:39 +0000 Subject: [PATCH 0744/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 08d1e8067e59946955b1cb2a98e09cdb9abffe78 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 10 Nov 2025 10:22:39 +0000 Subject: [PATCH 0745/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 670db710cad0416f95369237645bc9d46d44afcb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 10 Nov 2025 11:28:31 +0000 Subject: [PATCH 0746/1108] chore(package): drop Python 3.8 support --- README.md | 4 ++-- pyproject.toml | 5 ++--- src/agentex/_utils/_sync.py | 34 +++------------------------------- 3 files changed, 7 insertions(+), 36 deletions(-) diff --git a/README.md b/README.md index 777bdddd..ae6a4d16 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ [![PyPI version](https://img.shields.io/pypi/v/agentex-sdk.svg?label=pypi%20(stable))](https://pypi.org/project/agentex-sdk/) -The Agentex Python library provides convenient access to the Agentex REST API from any Python 3.8+ +The Agentex Python library provides convenient access to the Agentex REST API from any Python 3.9+ application. The library includes type definitions for all request params and response fields, and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx). @@ -357,7 +357,7 @@ print(agentex.__version__) ## Requirements -Python 3.8 or higher. +Python 3.9 or higher. ## Contributing diff --git a/pyproject.toml b/pyproject.toml index 31d0bc28..289cebfc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -15,11 +15,10 @@ dependencies = [ "distro>=1.7.0, <2", "sniffio", ] -requires-python = ">= 3.8" +requires-python = ">= 3.9" classifiers = [ "Typing :: Typed", "Intended Audience :: Developers", - "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", @@ -141,7 +140,7 @@ filterwarnings = [ # there are a couple of flags that are still disabled by # default in strict mode as they are experimental and niche. typeCheckingMode = "strict" -pythonVersion = "3.8" +pythonVersion = "3.9" exclude = [ "_dev", diff --git a/src/agentex/_utils/_sync.py b/src/agentex/_utils/_sync.py index ad7ec71b..f6027c18 100644 --- a/src/agentex/_utils/_sync.py +++ b/src/agentex/_utils/_sync.py @@ -1,10 +1,8 @@ from __future__ import annotations -import sys import asyncio import functools -import contextvars -from typing import Any, TypeVar, Callable, Awaitable +from typing import TypeVar, Callable, Awaitable from typing_extensions import ParamSpec import anyio @@ -15,34 +13,11 @@ T_ParamSpec = ParamSpec("T_ParamSpec") -if sys.version_info >= (3, 9): - _asyncio_to_thread = asyncio.to_thread -else: - # backport of https://docs.python.org/3/library/asyncio-task.html#asyncio.to_thread - # for Python 3.8 support - async def _asyncio_to_thread( - func: Callable[T_ParamSpec, T_Retval], /, *args: T_ParamSpec.args, **kwargs: T_ParamSpec.kwargs - ) -> Any: - """Asynchronously run function *func* in a separate thread. - - Any *args and **kwargs supplied for this function are directly passed - to *func*. Also, the current :class:`contextvars.Context` is propagated, - allowing context variables from the main thread to be accessed in the - separate thread. - - Returns a coroutine that can be awaited to get the eventual result of *func*. - """ - loop = asyncio.events.get_running_loop() - ctx = contextvars.copy_context() - func_call = functools.partial(ctx.run, func, *args, **kwargs) - return await loop.run_in_executor(None, func_call) - - async def to_thread( func: Callable[T_ParamSpec, T_Retval], /, *args: T_ParamSpec.args, **kwargs: T_ParamSpec.kwargs ) -> T_Retval: if sniffio.current_async_library() == "asyncio": - return await _asyncio_to_thread(func, *args, **kwargs) + return await asyncio.to_thread(func, *args, **kwargs) return await anyio.to_thread.run_sync( functools.partial(func, *args, **kwargs), @@ -53,10 +28,7 @@ async def to_thread( def asyncify(function: Callable[T_ParamSpec, T_Retval]) -> Callable[T_ParamSpec, Awaitable[T_Retval]]: """ Take a blocking function and create an async one that receives the same - positional and keyword arguments. For python version 3.9 and above, it uses - asyncio.to_thread to run the function in a separate thread. For python version - 3.8, it uses locally defined copy of the asyncio.to_thread function which was - introduced in python 3.9. + positional and keyword arguments. Usage: From e76d47ffaf25bfd374a9c9d465b5cf2741b8aada Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 10 Nov 2025 12:22:38 +0000 Subject: [PATCH 0747/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 4ae9d1aacf8f21eb6081963d764cd47d530ffcd8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 10 Nov 2025 13:35:58 +0000 Subject: [PATCH 0748/1108] fix: compat with Python 3.14 --- src/agentex/_models.py | 11 ++++++++--- tests/test_models.py | 8 ++++---- 2 files changed, 12 insertions(+), 7 deletions(-) diff --git a/src/agentex/_models.py b/src/agentex/_models.py index 6a3cd1d2..fcec2cf9 100644 --- a/src/agentex/_models.py +++ b/src/agentex/_models.py @@ -2,6 +2,7 @@ import os import inspect +import weakref from typing import TYPE_CHECKING, Any, Type, Union, Generic, TypeVar, Callable, Optional, cast from datetime import date, datetime from typing_extensions import ( @@ -573,6 +574,9 @@ class CachedDiscriminatorType(Protocol): __discriminator__: DiscriminatorDetails +DISCRIMINATOR_CACHE: weakref.WeakKeyDictionary[type, DiscriminatorDetails] = weakref.WeakKeyDictionary() + + class DiscriminatorDetails: field_name: str """The name of the discriminator field in the variant class, e.g. @@ -615,8 +619,9 @@ def __init__( def _build_discriminated_union_meta(*, union: type, meta_annotations: tuple[Any, ...]) -> DiscriminatorDetails | None: - if isinstance(union, CachedDiscriminatorType): - return union.__discriminator__ + cached = DISCRIMINATOR_CACHE.get(union) + if cached is not None: + return cached discriminator_field_name: str | None = None @@ -669,7 +674,7 @@ def _build_discriminated_union_meta(*, union: type, meta_annotations: tuple[Any, discriminator_field=discriminator_field_name, discriminator_alias=discriminator_alias, ) - cast(CachedDiscriminatorType, union).__discriminator__ = details + DISCRIMINATOR_CACHE.setdefault(union, details) return details diff --git a/tests/test_models.py b/tests/test_models.py index d2f03273..1aef5c60 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -9,7 +9,7 @@ from agentex._utils import PropertyInfo from agentex._compat import PYDANTIC_V1, parse_obj, model_dump, model_json -from agentex._models import BaseModel, construct_type +from agentex._models import DISCRIMINATOR_CACHE, BaseModel, construct_type class BasicModel(BaseModel): @@ -809,7 +809,7 @@ class B(BaseModel): UnionType = cast(Any, Union[A, B]) - assert not hasattr(UnionType, "__discriminator__") + assert not DISCRIMINATOR_CACHE.get(UnionType) m = construct_type( value={"type": "b", "data": "foo"}, type_=cast(Any, Annotated[UnionType, PropertyInfo(discriminator="type")]) @@ -818,7 +818,7 @@ class B(BaseModel): assert m.type == "b" assert m.data == "foo" # type: ignore[comparison-overlap] - discriminator = UnionType.__discriminator__ + discriminator = DISCRIMINATOR_CACHE.get(UnionType) assert discriminator is not None m = construct_type( @@ -830,7 +830,7 @@ class B(BaseModel): # if the discriminator details object stays the same between invocations then # we hit the cache - assert UnionType.__discriminator__ is discriminator + assert DISCRIMINATOR_CACHE.get(UnionType) is discriminator @pytest.mark.skipif(PYDANTIC_V1, reason="TypeAliasType is not supported in Pydantic v1") From da03300febeb004f69fd6ca57ba81f972f56b016 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 10 Nov 2025 14:22:29 +0000 Subject: [PATCH 0749/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 66e2f4cf7c97aa500253eb891fa8001640378dd4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 10 Nov 2025 15:22:38 +0000 Subject: [PATCH 0750/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 560ce524a091ca6c1072a0fa393145c5e543fbf3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 10 Nov 2025 19:22:26 +0000 Subject: [PATCH 0751/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 497b70f2f62ca88a37fdb644fc09ad9e03ff6720 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 10 Nov 2025 20:22:36 +0000 Subject: [PATCH 0752/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 73657d1117136d55e48326e441fedf924e92c70c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 10 Nov 2025 21:22:29 +0000 Subject: [PATCH 0753/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 0611292f6901e1a80e7473e8a9465128f2ef7db2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 10 Nov 2025 22:22:37 +0000 Subject: [PATCH 0754/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From ad0ab6f8b7a9310b3f23c901e2a55c36716b69e2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 10 Nov 2025 23:22:27 +0000 Subject: [PATCH 0755/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From afb825ddd005502fb9344b2f7c89974991f521f3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 11 Nov 2025 04:22:32 +0000 Subject: [PATCH 0756/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 299db0fc1c4465ada8f87282b106235e99c92b0f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 11 Nov 2025 06:22:52 +0000 Subject: [PATCH 0757/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 033b65b0d61862195d2dd619773b3f33b8a7731e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 11 Nov 2025 09:22:33 +0000 Subject: [PATCH 0758/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From f1ef3b1f37ca08399dda538ab552b5be438ed70c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 11 Nov 2025 10:22:27 +0000 Subject: [PATCH 0759/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From dbf10ba302065103e0256c2f4195359d43c8a48d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 11 Nov 2025 13:22:32 +0000 Subject: [PATCH 0760/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 7505294550f66887a7e293e72ffa17138236ad8c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 11 Nov 2025 14:22:32 +0000 Subject: [PATCH 0761/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 2f9a0fdc57fe3bd6a212136258f10114773bd8c2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 11 Nov 2025 14:35:37 +0000 Subject: [PATCH 0762/1108] fix(compat): update signatures of `model_dump` and `model_dump_json` for Pydantic v1 --- src/agentex/_models.py | 41 +++++++++++++++++++++++++++++------------ 1 file changed, 29 insertions(+), 12 deletions(-) diff --git a/src/agentex/_models.py b/src/agentex/_models.py index fcec2cf9..ca9500b2 100644 --- a/src/agentex/_models.py +++ b/src/agentex/_models.py @@ -257,15 +257,16 @@ def model_dump( mode: Literal["json", "python"] | str = "python", include: IncEx | None = None, exclude: IncEx | None = None, + context: Any | None = None, by_alias: bool | None = None, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, + exclude_computed_fields: bool = False, round_trip: bool = False, warnings: bool | Literal["none", "warn", "error"] = True, - context: dict[str, Any] | None = None, - serialize_as_any: bool = False, fallback: Callable[[Any], Any] | None = None, + serialize_as_any: bool = False, ) -> dict[str, Any]: """Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#modelmodel_dump @@ -273,16 +274,24 @@ def model_dump( Args: mode: The mode in which `to_python` should run. - If mode is 'json', the dictionary will only contain JSON serializable types. - If mode is 'python', the dictionary may contain any Python objects. - include: A list of fields to include in the output. - exclude: A list of fields to exclude from the output. + If mode is 'json', the output will only contain JSON serializable types. + If mode is 'python', the output may contain non-JSON-serializable Python objects. + include: A set of fields to include in the output. + exclude: A set of fields to exclude from the output. + context: Additional context to pass to the serializer. by_alias: Whether to use the field's alias in the dictionary key if defined. - exclude_unset: Whether to exclude fields that are unset or None from the output. - exclude_defaults: Whether to exclude fields that are set to their default value from the output. - exclude_none: Whether to exclude fields that have a value of `None` from the output. - round_trip: Whether to enable serialization and deserialization round-trip support. - warnings: Whether to log warnings when invalid fields are encountered. + exclude_unset: Whether to exclude fields that have not been explicitly set. + exclude_defaults: Whether to exclude fields that are set to their default value. + exclude_none: Whether to exclude fields that have a value of `None`. + exclude_computed_fields: Whether to exclude computed fields. + While this can be useful for round-tripping, it is usually recommended to use the dedicated + `round_trip` parameter instead. + round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T]. + warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors, + "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError]. + fallback: A function to call when an unknown value is encountered. If not provided, + a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised. + serialize_as_any: Whether to serialize fields with duck-typing serialization behavior. Returns: A dictionary representation of the model. @@ -299,6 +308,8 @@ def model_dump( raise ValueError("serialize_as_any is only supported in Pydantic v2") if fallback is not None: raise ValueError("fallback is only supported in Pydantic v2") + if exclude_computed_fields != False: + raise ValueError("exclude_computed_fields is only supported in Pydantic v2") dumped = super().dict( # pyright: ignore[reportDeprecated] include=include, exclude=exclude, @@ -315,15 +326,17 @@ def model_dump_json( self, *, indent: int | None = None, + ensure_ascii: bool = False, include: IncEx | None = None, exclude: IncEx | None = None, + context: Any | None = None, by_alias: bool | None = None, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, + exclude_computed_fields: bool = False, round_trip: bool = False, warnings: bool | Literal["none", "warn", "error"] = True, - context: dict[str, Any] | None = None, fallback: Callable[[Any], Any] | None = None, serialize_as_any: bool = False, ) -> str: @@ -355,6 +368,10 @@ def model_dump_json( raise ValueError("serialize_as_any is only supported in Pydantic v2") if fallback is not None: raise ValueError("fallback is only supported in Pydantic v2") + if ensure_ascii != False: + raise ValueError("ensure_ascii is only supported in Pydantic v2") + if exclude_computed_fields != False: + raise ValueError("exclude_computed_fields is only supported in Pydantic v2") return super().json( # type: ignore[reportDeprecated] indent=indent, include=include, From 2d78421079535793545585e213250c3ff360f6c8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 11 Nov 2025 15:22:33 +0000 Subject: [PATCH 0763/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 794af04e195a6fd722a0fa859886f585c1d9e6c0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 11 Nov 2025 16:22:33 +0000 Subject: [PATCH 0764/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From b646b56eda7171889a4798fa168794cc236cc4b1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 11 Nov 2025 18:22:29 +0000 Subject: [PATCH 0765/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 321dd91106345275a73b93501265a96fe835db83 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 11 Nov 2025 19:22:31 +0000 Subject: [PATCH 0766/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 98100301dd2e55424db8fa2312c134e6dc04d587 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 11 Nov 2025 20:22:30 +0000 Subject: [PATCH 0767/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 7b10ed882b3de2c7f2c7316812fddc986ec6fff5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 11 Nov 2025 21:22:30 +0000 Subject: [PATCH 0768/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 3d2d83d8d5e8e16047e062b3ffc3afc2bf884ad1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 11 Nov 2025 22:22:39 +0000 Subject: [PATCH 0769/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 1b512983b8b08a5676c0bc54425e6b5ca012d7ed Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 11 Nov 2025 23:22:33 +0000 Subject: [PATCH 0770/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 0c07e37e7f90c9936511d656a7645672f092e60a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 12 Nov 2025 00:22:30 +0000 Subject: [PATCH 0771/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From d121f30496d53c35ee1f1788a5416c593d433383 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 12 Nov 2025 02:22:29 +0000 Subject: [PATCH 0772/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 09d6d2647608957ca26c05194a0e3fdd4cde88f5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 12 Nov 2025 04:22:28 +0000 Subject: [PATCH 0773/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From a4178f8d34d913470d8a92dbb60c7e593f8862d1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 12 Nov 2025 05:22:28 +0000 Subject: [PATCH 0774/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 9604df4a2dca019e50ab5fed0cfb0d45dc0df171 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 12 Nov 2025 06:22:29 +0000 Subject: [PATCH 0775/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 495aeefb3fa7973d674b036ea53a5c50bc9d97a1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 13 Nov 2025 22:22:26 +0000 Subject: [PATCH 0776/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From fe4eddd4d9c88359f82cba051785c5328d437864 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 14 Nov 2025 16:22:20 +0000 Subject: [PATCH 0777/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 7645cd999379663e6ce326bd8dbad5c6afcdee80 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 14 Nov 2025 17:22:21 +0000 Subject: [PATCH 0778/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 293f01c34bc58ac6aa51601e326e6cf4589ab74c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 14 Nov 2025 18:22:20 +0000 Subject: [PATCH 0779/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 2d756127a57ccd9262c0607df0783a3ee5259b31 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 14 Nov 2025 19:22:24 +0000 Subject: [PATCH 0780/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From f496791d29e5262bcf17a31e9ed7638f1e178ba5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 14 Nov 2025 21:22:39 +0000 Subject: [PATCH 0781/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 9a5a3191394a871dd20261e0eb5bcdc321348597 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 15 Nov 2025 01:22:17 +0000 Subject: [PATCH 0782/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 7904504a33ccdfcac4b647115bf94454f7402bcc Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 15 Nov 2025 02:22:17 +0000 Subject: [PATCH 0783/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From d68b01b29f79a17b250753ce3a7ba492d70c1e3f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 15 Nov 2025 04:22:17 +0000 Subject: [PATCH 0784/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From d7d4fe165d1d2d8192fd3fee30b50c7da3204ad1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 15 Nov 2025 06:22:17 +0000 Subject: [PATCH 0785/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 35b5a8a5579f52f259321a836b2cdcdcd4f0bcc8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 15 Nov 2025 08:22:17 +0000 Subject: [PATCH 0786/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 87f8ba625c3b2c793adccf323c323328ff29ba44 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 15 Nov 2025 11:22:16 +0000 Subject: [PATCH 0787/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c29bea03f0fa10fa6a468572f72a584ae89c97c9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 15 Nov 2025 14:22:17 +0000 Subject: [PATCH 0788/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 52b9744d5e996e1f07b725f3cef855dc6fa8861b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 15 Nov 2025 15:22:17 +0000 Subject: [PATCH 0789/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 182a77ad76cb3889b69e6df548ca090180a609f0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 15 Nov 2025 20:22:22 +0000 Subject: [PATCH 0790/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From f26b2fd9dbfff18f3c27fce9cbe2c5b12cf70767 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 16 Nov 2025 00:22:18 +0000 Subject: [PATCH 0791/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 545c8b66d117f7a1fb28c00f5a34d4daaa33f666 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 16 Nov 2025 02:22:17 +0000 Subject: [PATCH 0792/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 718df00197b1c36ab1f76b1d4ad44dca2525eb05 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 16 Nov 2025 07:22:16 +0000 Subject: [PATCH 0793/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 248a44fb8d0e36d6dba7b5e950e615c19a315622 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 16 Nov 2025 08:22:17 +0000 Subject: [PATCH 0794/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From dd01dcb2ac420532b94ca298d6ffd143d359ac1a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 16 Nov 2025 09:22:16 +0000 Subject: [PATCH 0795/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From f0c950946008c7b49a1a996a978d9290bc7689ee Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 16 Nov 2025 12:22:16 +0000 Subject: [PATCH 0796/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 97d707d1bfb700f193f12ebc51b921775e7c786a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 16 Nov 2025 15:22:17 +0000 Subject: [PATCH 0797/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 162f6a33c1d81eba560b0b995b6e0d29392c1380 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 16 Nov 2025 17:22:18 +0000 Subject: [PATCH 0798/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 0022c8c594d3e7926422907e268a9556cb9de1c0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 16 Nov 2025 18:22:17 +0000 Subject: [PATCH 0799/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 30891ee4d1b3f4e8156c9655e194574fb43a07e1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 16 Nov 2025 21:22:17 +0000 Subject: [PATCH 0800/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From f302591cbeb751fd215769775af4609cf3e6508e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 17 Nov 2025 03:22:16 +0000 Subject: [PATCH 0801/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 3b132efe9f98fac39fd7817e541c55d8c9739635 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 17 Nov 2025 04:22:17 +0000 Subject: [PATCH 0802/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 77d48a9ff8dedfdf442a2ebbea1190eb27786ed6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 17 Nov 2025 08:22:18 +0000 Subject: [PATCH 0803/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c58138212a13396d4d00bd44bd3448aa20bd699e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 17 Nov 2025 10:22:17 +0000 Subject: [PATCH 0804/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 9ae6bef32729bb32f2939a7dcbd44da6c09772fa Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 17 Nov 2025 11:22:17 +0000 Subject: [PATCH 0805/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From b9a57dedf575187f8ac2f3fa2ab3dbaa17e588ef Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 17 Nov 2025 14:22:18 +0000 Subject: [PATCH 0806/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 51c9e72b0d02ee0153bd73ea16f2383e65287102 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 17 Nov 2025 16:23:27 +0000 Subject: [PATCH 0807/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From b9d3d36d10d83d24f1f35bb10c7996b1a3627fbe Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 17 Nov 2025 19:26:17 +0000 Subject: [PATCH 0808/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 9a49ee875591174c717dc84f8825a8bcb2869944 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 17 Nov 2025 20:24:14 +0000 Subject: [PATCH 0809/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 3ec14fe25ac41f38259db3d01d12a910fe5ea43b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 17 Nov 2025 21:24:01 +0000 Subject: [PATCH 0810/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From d93d59a15d8b2196f6e5b875ad21b60a8bffb69f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 17 Nov 2025 23:24:08 +0000 Subject: [PATCH 0811/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e564b0e700f2dcaadb0c8441d2d854d0776012be Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 18 Nov 2025 00:24:12 +0000 Subject: [PATCH 0812/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 01566e702a31e75322f23c6382efad74edb8be93 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 18 Nov 2025 01:24:09 +0000 Subject: [PATCH 0813/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 811b8d6e264c1b7d89d8288c52effaf4151a0919 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 18 Nov 2025 05:24:23 +0000 Subject: [PATCH 0814/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From ddce8f8c45d2957854e59c7f05f2e052fe5867ea Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 18 Nov 2025 06:24:11 +0000 Subject: [PATCH 0815/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 24a40c734c328b8a8fc7070bc2e57588b99f0260 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 18 Nov 2025 08:24:10 +0000 Subject: [PATCH 0816/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 427df543a410d2edb47ecf6c500191587e5a313c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 18 Nov 2025 11:23:54 +0000 Subject: [PATCH 0817/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From a0fe45f3d78f22ab5d2a1e749039c9a405c0b40a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 18 Nov 2025 12:23:59 +0000 Subject: [PATCH 0818/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From da1345f5de6702dd1b367aa0a706dce17dd225fa Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 18 Nov 2025 16:23:53 +0000 Subject: [PATCH 0819/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From bca4cd29b6d0baed4457fb4ac78940afe00db86d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 18 Nov 2025 18:23:53 +0000 Subject: [PATCH 0820/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 3752e5be563ec3543dd28bd0aa26c9faa79bee66 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 18 Nov 2025 20:24:04 +0000 Subject: [PATCH 0821/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 43b0bdb3cbd7a03c3e59aa218951b5c6436a22fc Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 18 Nov 2025 23:23:50 +0000 Subject: [PATCH 0822/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From fcfe6db2ed5455b28befbc0566bd60d6b2df1be3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 19 Nov 2025 01:42:32 +0000 Subject: [PATCH 0823/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 40c9055557c5fd8b51c74daa895b66e7c5c92c8d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 19 Nov 2025 02:23:57 +0000 Subject: [PATCH 0824/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 6982dc6b4560992b32837e08cf960af6474b95e9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 19 Nov 2025 05:23:52 +0000 Subject: [PATCH 0825/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 588c32f6d921b3c50c7d9b92348fff12adba9d28 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 19 Nov 2025 06:24:15 +0000 Subject: [PATCH 0826/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From fa4e6b700ff82758935b21f93b26a32e14e48bce Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 19 Nov 2025 07:23:57 +0000 Subject: [PATCH 0827/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 6e6e472f32102b680e52f335bf84eb68085ee9ea Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 19 Nov 2025 09:24:13 +0000 Subject: [PATCH 0828/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 64e3c0bad7e5b128ab0e9ef4c6e348dde03e73dc Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 19 Nov 2025 11:23:58 +0000 Subject: [PATCH 0829/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 5ad9edb6d68379553077c8197ee8faa7fbee2d44 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 19 Nov 2025 14:23:52 +0000 Subject: [PATCH 0830/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 58d5c2168ec79e4a0fc6110a9d8032233b2dc9a8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 19 Nov 2025 15:24:20 +0000 Subject: [PATCH 0831/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 673f8582ff3dc922e462c5dd1c2ccdddce75a9f1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 19 Nov 2025 16:23:57 +0000 Subject: [PATCH 0832/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 7586618e8967737b253e96ccfd182f089d60c61c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 19 Nov 2025 17:23:50 +0000 Subject: [PATCH 0833/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From b3aae5b7a457ef50754557214bca4dbd746a6fc3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 19 Nov 2025 18:24:03 +0000 Subject: [PATCH 0834/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 3aee0b9fced8586c892b70f0e49c328f4865c482 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 19 Nov 2025 20:41:01 +0000 Subject: [PATCH 0835/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index e90b36cc..a25d414b 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.6.5" + ".": "0.6.7" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 289cebfc..cdba1124 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.6.5" +version = "0.6.7" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 34669904..f5647ae4 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.6.5" # x-release-please-version +__version__ = "0.6.7" # x-release-please-version From 7e29edfb0ed2ecfc36ec30bfc291013532aeb03f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 19 Nov 2025 21:23:55 +0000 Subject: [PATCH 0836/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From eba678f43f00d7b8e84762e364a0699cc6b4edc5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 20 Nov 2025 00:23:57 +0000 Subject: [PATCH 0837/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e5cabe82ae4631ea5be96d014b1de323ed45d030 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 20 Nov 2025 01:23:52 +0000 Subject: [PATCH 0838/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From eebf1e97c8e467eed219667004001441e8864b2a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 20 Nov 2025 04:24:12 +0000 Subject: [PATCH 0839/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 0b901a041ed4575d1f265a51d3ff1bae4ffbf836 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 20 Nov 2025 06:23:57 +0000 Subject: [PATCH 0840/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c69d3b6138cd54d1a628c15d4b8b73374ae9917e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 20 Nov 2025 07:23:53 +0000 Subject: [PATCH 0841/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 1f6801b50fe3f58c92ba3e80d89608555315aeb1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 20 Nov 2025 08:23:58 +0000 Subject: [PATCH 0842/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c8d979e4dbfaa339399d2a2b2b17efd7676c8c04 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 20 Nov 2025 10:23:52 +0000 Subject: [PATCH 0843/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c7bdb1d760726ccd39f0c3570f238715507e9345 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 20 Nov 2025 13:23:58 +0000 Subject: [PATCH 0844/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 89637de2dbd4999a1a33ea54e54709aec1e460ae Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 20 Nov 2025 15:23:59 +0000 Subject: [PATCH 0845/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 4b5681bb4525d5a4e0c607483b3269aeffdce220 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 20 Nov 2025 22:23:46 +0000 Subject: [PATCH 0846/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 3cdbae923abefb21e9de01b135002ca5f94ecbf5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 20 Nov 2025 23:24:49 +0000 Subject: [PATCH 0847/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From b808da4c3bc58e51d9756f63cadd26779b59318b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 21 Nov 2025 01:23:57 +0000 Subject: [PATCH 0848/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 883c231d50745c1b21a26d0b2a42a0e40fa4d815 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 21 Nov 2025 03:23:50 +0000 Subject: [PATCH 0849/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 94f862ce00a3c46346fe1ad425cf9973898cb39c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 21 Nov 2025 05:23:45 +0000 Subject: [PATCH 0850/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 10f47f1f660fa2124e1cfd4090663c7a7e846ab9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 21 Nov 2025 06:23:55 +0000 Subject: [PATCH 0851/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From d397860e996d1dad76996372b120f39cc758ffce Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 21 Nov 2025 10:23:49 +0000 Subject: [PATCH 0852/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 03bdb6d5fbba69e03b513ab0184897a54a64f850 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 21 Nov 2025 11:23:47 +0000 Subject: [PATCH 0853/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From b0af128888550647a20d3b0882cf4ec6663b2d7b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 21 Nov 2025 13:24:00 +0000 Subject: [PATCH 0854/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 13860d9d2a8e2911c1a278ff26359a397ce86042 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 21 Nov 2025 15:23:57 +0000 Subject: [PATCH 0855/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From be3e425410a94216aad248ec0867572c8c31190d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 21 Nov 2025 16:24:00 +0000 Subject: [PATCH 0856/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 4a9ee4d99208000891c028079629fa4f20240f6f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 21 Nov 2025 23:26:39 +0000 Subject: [PATCH 0857/1108] chore(internal): codegen related update --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index cdba1124..807924fa 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -24,6 +24,7 @@ classifiers = [ "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", "Operating System :: OS Independent", "Operating System :: POSIX", "Operating System :: MacOS", From 467747fcb1ad3e8445ec739788cfb9e27925c83f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 22 Nov 2025 00:23:44 +0000 Subject: [PATCH 0858/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 483cbd7517aadcf9e29577d99948e3034387e040 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 22 Nov 2025 02:23:57 +0000 Subject: [PATCH 0859/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From d1afabdcedf4b84aba506fa3d28dc403a4f7592d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 22 Nov 2025 03:23:56 +0000 Subject: [PATCH 0860/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 000a4fe7cf0b189677e1866da625ade0244b5ec2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 22 Nov 2025 06:23:56 +0000 Subject: [PATCH 0861/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From dfee674a8081d38d0aa5ded219fea8cb4cb161d1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 22 Nov 2025 07:23:48 +0000 Subject: [PATCH 0862/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From f29633eeab74ecccd755b11e1523fbb862138e8b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 22 Nov 2025 09:23:56 +0000 Subject: [PATCH 0863/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 51deccfe828a76bd14ba7d00b1078c2a6f799bb7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 22 Nov 2025 15:23:53 +0000 Subject: [PATCH 0864/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 442dde123fff590010e732de1f9f187b1ece03b4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 22 Nov 2025 22:23:48 +0000 Subject: [PATCH 0865/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e4b1e95a0d37b2fc72f48a8e5db1848f6349c5cd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 22 Nov 2025 23:23:54 +0000 Subject: [PATCH 0866/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 21794f700d6feff2e9ae30d7ba9543c56fb9de10 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 23 Nov 2025 00:23:46 +0000 Subject: [PATCH 0867/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c016d217870956cdb8ae3e0e38cdb085bfabd447 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 23 Nov 2025 01:23:52 +0000 Subject: [PATCH 0868/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e49fadacb7702523eff01ed3fd93cc63b551712e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 23 Nov 2025 02:24:38 +0000 Subject: [PATCH 0869/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 6e0cf4204a4b639e0d6abeab059542529b62ec79 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 23 Nov 2025 04:23:58 +0000 Subject: [PATCH 0870/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 39ea9e8034881c7cdb552ff6d8beed5bbd5a04d0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 23 Nov 2025 07:23:45 +0000 Subject: [PATCH 0871/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 2a11e4d41993b201369bacef05318b7174a5b323 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 23 Nov 2025 08:23:51 +0000 Subject: [PATCH 0872/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 8289cce4b7fbf2d0880df58ccd7ffe45d9d7d9ab Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 23 Nov 2025 10:23:47 +0000 Subject: [PATCH 0873/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 2fc157f22a79fa36439469a5d162238b0f7eb313 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 23 Nov 2025 18:23:47 +0000 Subject: [PATCH 0874/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 7bb9c0b3d4b30d8a80f31487e1767098126cbe98 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 24 Nov 2025 03:23:56 +0000 Subject: [PATCH 0875/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From b5dea7bee849ae73e70e221d7332457b49fb1f3b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 24 Nov 2025 04:23:44 +0000 Subject: [PATCH 0876/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 559ce0f5f5b87056874a3a0625e3ca06e5b73da4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 24 Nov 2025 05:23:55 +0000 Subject: [PATCH 0877/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From bbad158a8945eab36a3417b7cf729f2beecd9737 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 24 Nov 2025 09:23:50 +0000 Subject: [PATCH 0878/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c2645779110b15545b8921f2dd6fa561038d7f38 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 24 Nov 2025 10:23:45 +0000 Subject: [PATCH 0879/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 65b758799c1df476c0a70d62f885da42d879d462 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 24 Nov 2025 11:23:56 +0000 Subject: [PATCH 0880/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c3aa49e4bee3cd0933c5e391d61a95f09c8ec3e5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 24 Nov 2025 13:23:53 +0000 Subject: [PATCH 0881/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From f748c1df359994dbee7efa0e5962cc29385eb024 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 24 Nov 2025 20:23:49 +0000 Subject: [PATCH 0882/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From fc81dc5075bb3e71dbeadd759525bdf509d562b4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 24 Nov 2025 21:23:53 +0000 Subject: [PATCH 0883/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 676e60fd750d89fe9c68cb7baec538500e71b184 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 24 Nov 2025 23:24:04 +0000 Subject: [PATCH 0884/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From b4c74d5666171e3d4a36b904de94bfba857e1dbe Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 25 Nov 2025 02:23:55 +0000 Subject: [PATCH 0885/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 05bbb74b4d84125e457b25efe59112aaac3b86c6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 25 Nov 2025 04:23:48 +0000 Subject: [PATCH 0886/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 4affc27e6f57f6ff9e9764537fd5b6a5716a95f2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 25 Nov 2025 05:23:54 +0000 Subject: [PATCH 0887/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 5d34f12ace238cc146c890b6603f75882f3a5b65 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 25 Nov 2025 06:23:44 +0000 Subject: [PATCH 0888/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 76faaac300aba7b2e335367213d8b182b8a0096d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 25 Nov 2025 08:23:45 +0000 Subject: [PATCH 0889/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c7f0a4914e24551378f25714557b766832d7b4fe Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 25 Nov 2025 10:23:45 +0000 Subject: [PATCH 0890/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From ffde7acd7a4df3ec7ad0cb902a05d61159d50f82 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 25 Nov 2025 12:24:01 +0000 Subject: [PATCH 0891/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 4172ba6784628d0231f410b53b7f8739826500ec Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 25 Nov 2025 14:23:50 +0000 Subject: [PATCH 0892/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 183af692f7abfa2f5976a11ff910a97038ccff08 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 25 Nov 2025 17:23:48 +0000 Subject: [PATCH 0893/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 7da10eff01f030a3d80bad197ec54308b206b1b2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 25 Nov 2025 18:31:05 +0000 Subject: [PATCH 0894/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 149f4d93d9ab146b26ef3c99d30506aa8111cc3d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 25 Nov 2025 19:26:07 +0000 Subject: [PATCH 0895/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 2e4a24fb133a69ba219f2ef8fcb31632f52cfdf5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 25 Nov 2025 21:26:11 +0000 Subject: [PATCH 0896/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From cdec54ed45fd7aec192c0ab77cb879332db4d09c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 26 Nov 2025 05:23:52 +0000 Subject: [PATCH 0897/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 254ac0ff145455aac2e64477abceb1122429a6bf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 26 Nov 2025 08:23:50 +0000 Subject: [PATCH 0898/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c3fe50be639e193ddbce45c4a5f368d4e25dd39f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 26 Nov 2025 09:23:50 +0000 Subject: [PATCH 0899/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 36dfde9ba28f1dd9883636304d09bda2c7c235b4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 26 Nov 2025 11:23:50 +0000 Subject: [PATCH 0900/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e3b9a2aa5312b16e96cff8f74adece35f31a18ea Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 26 Nov 2025 14:23:44 +0000 Subject: [PATCH 0901/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From a4fa7ee1df3adf64e8b0048580d046682a77e12c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 26 Nov 2025 15:23:56 +0000 Subject: [PATCH 0902/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From ff585e046c6c272187fde1194ad1831389651534 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 26 Nov 2025 16:23:54 +0000 Subject: [PATCH 0903/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..cf398e1e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml +openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e8f0f2a2a56e2b897e564fdb38ac94cc1da79b9c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 26 Nov 2025 17:23:44 +0000 Subject: [PATCH 0904/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index cf398e1e..da7496f1 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-b5b567ef5b14f4b23f01e69b75d282ba3cf0ce6e8f5d57c859e844fbbf99eed6.yml -openapi_spec_hash: 2ddd1cbab48974dbf6357c2c10ee4701 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml +openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 14d29b8b36f2e9f3a7ad9e5697d74ee1229931a3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 26 Nov 2025 20:23:43 +0000 Subject: [PATCH 0905/1108] feat(api): api update --- .stats.yml | 4 ++-- src/agentex/resources/agents.py | 16 ++++++++++++++++ src/agentex/resources/spans.py | 8 ++++++++ src/agentex/resources/tasks.py | 8 ++++++++ src/agentex/resources/tracker.py | 16 ++++++++++++++++ src/agentex/types/agent_list_params.py | 6 ++++++ src/agentex/types/span_list_params.py | 4 ++++ src/agentex/types/task_list_params.py | 4 ++++ src/agentex/types/tracker_list_params.py | 6 ++++++ tests/api_resources/test_agents.py | 4 ++++ tests/api_resources/test_spans.py | 4 ++++ tests/api_resources/test_tasks.py | 4 ++++ tests/api_resources/test_tracker.py | 4 ++++ 13 files changed, 86 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index da7496f1..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-17022011bf153e3ac9e20d23c5dca8a3072b0e735b47bb391b6e35b00348d5a5.yml -openapi_spec_hash: 0927cdce49a6e6915d6060c2ab43b0d0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 diff --git a/src/agentex/resources/agents.py b/src/agentex/resources/agents.py index 06124820..daf0b005 100644 --- a/src/agentex/resources/agents.py +++ b/src/agentex/resources/agents.py @@ -84,6 +84,8 @@ def list( self, *, limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, page_number: int | Omit = omit, task_id: Optional[str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -99,6 +101,10 @@ def list( Args: limit: Limit + order_by: Field to order by + + order_direction: Order direction (asc or desc) + page_number: Page number task_id: Task ID @@ -121,6 +127,8 @@ def list( query=maybe_transform( { "limit": limit, + "order_by": order_by, + "order_direction": order_direction, "page_number": page_number, "task_id": task_id, }, @@ -383,6 +391,8 @@ async def list( self, *, limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, page_number: int | Omit = omit, task_id: Optional[str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -398,6 +408,10 @@ async def list( Args: limit: Limit + order_by: Field to order by + + order_direction: Order direction (asc or desc) + page_number: Page number task_id: Task ID @@ -420,6 +434,8 @@ async def list( query=await async_maybe_transform( { "limit": limit, + "order_by": order_by, + "order_direction": order_direction, "page_number": page_number, "task_id": task_id, }, diff --git a/src/agentex/resources/spans.py b/src/agentex/resources/spans.py index 427ae079..589c2ac6 100644 --- a/src/agentex/resources/spans.py +++ b/src/agentex/resources/spans.py @@ -223,6 +223,8 @@ def list( self, *, limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, page_number: int | Omit = omit, trace_id: Optional[str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -254,6 +256,8 @@ def list( query=maybe_transform( { "limit": limit, + "order_by": order_by, + "order_direction": order_direction, "page_number": page_number, "trace_id": trace_id, }, @@ -462,6 +466,8 @@ async def list( self, *, limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, page_number: int | Omit = omit, trace_id: Optional[str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -493,6 +499,8 @@ async def list( query=await async_maybe_transform( { "limit": limit, + "order_by": order_by, + "order_direction": order_direction, "page_number": page_number, "trace_id": trace_id, }, diff --git a/src/agentex/resources/tasks.py b/src/agentex/resources/tasks.py index a941c42b..1bf41b7b 100644 --- a/src/agentex/resources/tasks.py +++ b/src/agentex/resources/tasks.py @@ -92,6 +92,8 @@ def list( agent_id: Optional[str] | Omit = omit, agent_name: Optional[str] | Omit = omit, limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, page_number: int | Omit = omit, relationships: List[Literal["agents"]] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -125,6 +127,8 @@ def list( "agent_id": agent_id, "agent_name": agent_name, "limit": limit, + "order_by": order_by, + "order_direction": order_direction, "page_number": page_number, "relationships": relationships, }, @@ -377,6 +381,8 @@ async def list( agent_id: Optional[str] | Omit = omit, agent_name: Optional[str] | Omit = omit, limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, page_number: int | Omit = omit, relationships: List[Literal["agents"]] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -410,6 +416,8 @@ async def list( "agent_id": agent_id, "agent_name": agent_name, "limit": limit, + "order_by": order_by, + "order_direction": order_direction, "page_number": page_number, "relationships": relationships, }, diff --git a/src/agentex/resources/tracker.py b/src/agentex/resources/tracker.py index 516e958f..15906b3f 100644 --- a/src/agentex/resources/tracker.py +++ b/src/agentex/resources/tracker.py @@ -132,6 +132,8 @@ def list( *, agent_id: Optional[str] | Omit = omit, limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, page_number: int | Omit = omit, task_id: Optional[str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -149,6 +151,10 @@ def list( limit: Limit + order_by: Field to order by + + order_direction: Order direction (asc or desc) + page_number: Page number task_id: Task ID @@ -172,6 +178,8 @@ def list( { "agent_id": agent_id, "limit": limit, + "order_by": order_by, + "order_direction": order_direction, "page_number": page_number, "task_id": task_id, }, @@ -290,6 +298,8 @@ async def list( *, agent_id: Optional[str] | Omit = omit, limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, page_number: int | Omit = omit, task_id: Optional[str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -307,6 +317,10 @@ async def list( limit: Limit + order_by: Field to order by + + order_direction: Order direction (asc or desc) + page_number: Page number task_id: Task ID @@ -330,6 +344,8 @@ async def list( { "agent_id": agent_id, "limit": limit, + "order_by": order_by, + "order_direction": order_direction, "page_number": page_number, "task_id": task_id, }, diff --git a/src/agentex/types/agent_list_params.py b/src/agentex/types/agent_list_params.py index a724de35..084fdfae 100644 --- a/src/agentex/types/agent_list_params.py +++ b/src/agentex/types/agent_list_params.py @@ -12,6 +12,12 @@ class AgentListParams(TypedDict, total=False): limit: int """Limit""" + order_by: Optional[str] + """Field to order by""" + + order_direction: str + """Order direction (asc or desc)""" + page_number: int """Page number""" diff --git a/src/agentex/types/span_list_params.py b/src/agentex/types/span_list_params.py index fc9280b0..40d4d651 100644 --- a/src/agentex/types/span_list_params.py +++ b/src/agentex/types/span_list_params.py @@ -11,6 +11,10 @@ class SpanListParams(TypedDict, total=False): limit: int + order_by: Optional[str] + + order_direction: str + page_number: int trace_id: Optional[str] diff --git a/src/agentex/types/task_list_params.py b/src/agentex/types/task_list_params.py index 6c417eb0..e41bf821 100644 --- a/src/agentex/types/task_list_params.py +++ b/src/agentex/types/task_list_params.py @@ -15,6 +15,10 @@ class TaskListParams(TypedDict, total=False): limit: int + order_by: Optional[str] + + order_direction: str + page_number: int relationships: List[Literal["agents"]] diff --git a/src/agentex/types/tracker_list_params.py b/src/agentex/types/tracker_list_params.py index e90dbbb4..57234f4a 100644 --- a/src/agentex/types/tracker_list_params.py +++ b/src/agentex/types/tracker_list_params.py @@ -15,6 +15,12 @@ class TrackerListParams(TypedDict, total=False): limit: int """Limit""" + order_by: Optional[str] + """Field to order by""" + + order_direction: str + """Order direction (asc or desc)""" + page_number: int """Page number""" diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index c99d653b..340238ba 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -75,6 +75,8 @@ def test_method_list(self, client: Agentex) -> None: def test_method_list_with_all_params(self, client: Agentex) -> None: agent = client.agents.list( limit=1, + order_by="order_by", + order_direction="order_direction", page_number=1, task_id="task_id", ) @@ -417,6 +419,8 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.list( limit=1, + order_by="order_by", + order_direction="order_direction", page_number=1, task_id="task_id", ) diff --git a/tests/api_resources/test_spans.py b/tests/api_resources/test_spans.py index 0fb99b51..ef991d4e 100644 --- a/tests/api_resources/test_spans.py +++ b/tests/api_resources/test_spans.py @@ -185,6 +185,8 @@ def test_method_list(self, client: Agentex) -> None: def test_method_list_with_all_params(self, client: Agentex) -> None: span = client.spans.list( limit=0, + order_by="order_by", + order_direction="order_direction", page_number=0, trace_id="trace_id", ) @@ -385,6 +387,8 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.list( limit=0, + order_by="order_by", + order_direction="order_direction", page_number=0, trace_id="trace_id", ) diff --git a/tests/api_resources/test_tasks.py b/tests/api_resources/test_tasks.py index eaf05fe2..6c2f2c54 100644 --- a/tests/api_resources/test_tasks.py +++ b/tests/api_resources/test_tasks.py @@ -86,6 +86,8 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: agent_id="agent_id", agent_name="agent_name", limit=0, + order_by="order_by", + order_direction="order_direction", page_number=0, relationships=["agents"], ) @@ -400,6 +402,8 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> agent_id="agent_id", agent_name="agent_name", limit=0, + order_by="order_by", + order_direction="order_direction", page_number=0, relationships=["agents"], ) diff --git a/tests/api_resources/test_tracker.py b/tests/api_resources/test_tracker.py index 04a6c9d6..5ea656f6 100644 --- a/tests/api_resources/test_tracker.py +++ b/tests/api_resources/test_tracker.py @@ -124,6 +124,8 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: tracker = client.tracker.list( agent_id="agent_id", limit=1, + order_by="order_by", + order_direction="order_direction", page_number=1, task_id="task_id", ) @@ -264,6 +266,8 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> tracker = await async_client.tracker.list( agent_id="agent_id", limit=1, + order_by="order_by", + order_direction="order_direction", page_number=1, task_id="task_id", ) From bcd57c5d81a8726054a7030d287e66e8cb9cccaa Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 26 Nov 2025 22:23:54 +0000 Subject: [PATCH 0906/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 8b31a60a81c1251fbb46fd68d68cc11f0e105036 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 27 Nov 2025 01:23:44 +0000 Subject: [PATCH 0907/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 5b4713786c726281945590999a13faa410fe0438 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 27 Nov 2025 02:23:54 +0000 Subject: [PATCH 0908/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 5921a20054a8d4ba1a343e5d59185fc0d6a309bb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 27 Nov 2025 05:23:56 +0000 Subject: [PATCH 0909/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 6a658ec6c340b4398fe75efe965a11452cfffe60 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 27 Nov 2025 06:23:51 +0000 Subject: [PATCH 0910/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 48defd9a06333536d8bcb6ab2e7e995336be9469 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 27 Nov 2025 07:23:37 +0000 Subject: [PATCH 0911/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From f5a8c34d0093b090271ce93c475029f11f2dc92f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 27 Nov 2025 12:23:39 +0000 Subject: [PATCH 0912/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From a13a6c47e28fc29b685244fdd187cf82db1362d9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 27 Nov 2025 15:23:35 +0000 Subject: [PATCH 0913/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 5035e4776225f5afba4f72a06de8b7596f5935ed Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 27 Nov 2025 16:23:51 +0000 Subject: [PATCH 0914/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 26ccab8eda9315a04832894942d8a2672edd5602 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 27 Nov 2025 16:48:40 +0000 Subject: [PATCH 0915/1108] fix: ensure streams are always closed --- src/agentex/_streaming.py | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/src/agentex/_streaming.py b/src/agentex/_streaming.py index ed1382cc..bfe61d2a 100644 --- a/src/agentex/_streaming.py +++ b/src/agentex/_streaming.py @@ -54,11 +54,12 @@ def __stream__(self) -> Iterator[_T]: process_data = self._client._process_response_data iterator = self._iter_events() - for sse in iterator: - yield process_data(data=sse.json(), cast_to=cast_to, response=response) - - # As we might not fully consume the response stream, we need to close it explicitly - response.close() + try: + for sse in iterator: + yield process_data(data=sse.json(), cast_to=cast_to, response=response) + finally: + # Ensure the response is closed even if the consumer doesn't read all data + response.close() def __enter__(self) -> Self: return self @@ -117,11 +118,12 @@ async def __stream__(self) -> AsyncIterator[_T]: process_data = self._client._process_response_data iterator = self._iter_events() - async for sse in iterator: - yield process_data(data=sse.json(), cast_to=cast_to, response=response) - - # As we might not fully consume the response stream, we need to close it explicitly - await response.aclose() + try: + async for sse in iterator: + yield process_data(data=sse.json(), cast_to=cast_to, response=response) + finally: + # Ensure the response is closed even if the consumer doesn't read all data + await response.aclose() async def __aenter__(self) -> Self: return self From 1747ae62d1da6a66b23d20f7b0792eb0eebfef55 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 27 Nov 2025 17:23:41 +0000 Subject: [PATCH 0916/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 78e6d28214849620ffc4f07749e60d9074cd0210 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 27 Nov 2025 18:45:59 +0000 Subject: [PATCH 0917/1108] chore(deps): mypy 1.18.1 has a regression, pin to 1.17 --- pyproject.toml | 2 +- requirements-dev.lock | 4 +++- requirements.lock | 8 ++++---- 3 files changed, 8 insertions(+), 6 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 807924fa..4abe57e0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -46,7 +46,7 @@ managed = true # version pins are in requirements-dev.lock dev-dependencies = [ "pyright==1.1.399", - "mypy", + "mypy==1.17", "respx", "pytest", "pytest-asyncio", diff --git a/requirements-dev.lock b/requirements-dev.lock index dba96731..097694b9 100644 --- a/requirements-dev.lock +++ b/requirements-dev.lock @@ -72,7 +72,7 @@ mdurl==0.1.2 multidict==6.4.4 # via aiohttp # via yarl -mypy==1.14.1 +mypy==1.17.0 mypy-extensions==1.0.0 # via mypy nodeenv==1.8.0 @@ -81,6 +81,8 @@ nox==2023.4.22 packaging==23.2 # via nox # via pytest +pathspec==0.12.1 + # via mypy platformdirs==3.11.0 # via virtualenv pluggy==1.5.0 diff --git a/requirements.lock b/requirements.lock index cac2ae2e..3249fd77 100644 --- a/requirements.lock +++ b/requirements.lock @@ -55,21 +55,21 @@ multidict==6.4.4 propcache==0.3.1 # via aiohttp # via yarl -pydantic==2.11.9 +pydantic==2.12.5 # via agentex-sdk -pydantic-core==2.33.2 +pydantic-core==2.41.5 # via pydantic sniffio==1.3.0 # via agentex-sdk # via anyio -typing-extensions==4.12.2 +typing-extensions==4.15.0 # via agentex-sdk # via anyio # via multidict # via pydantic # via pydantic-core # via typing-inspection -typing-inspection==0.4.1 +typing-inspection==0.4.2 # via pydantic yarl==1.20.0 # via aiohttp From e17b7174279851d53e0265ea6e5263afe3a978a2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 27 Nov 2025 20:23:52 +0000 Subject: [PATCH 0918/1108] feat(api): api update --- .stats.yml | 4 ++-- .../090_claude_agents_sdk_mvp/workspace/.gitignore | 4 ++++ 2 files changed, 6 insertions(+), 2 deletions(-) create mode 100644 examples/tutorials/10_async/10_temporal/090_claude_agents_sdk_mvp/workspace/.gitignore diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 diff --git a/examples/tutorials/10_async/10_temporal/090_claude_agents_sdk_mvp/workspace/.gitignore b/examples/tutorials/10_async/10_temporal/090_claude_agents_sdk_mvp/workspace/.gitignore new file mode 100644 index 00000000..3b65a466 --- /dev/null +++ b/examples/tutorials/10_async/10_temporal/090_claude_agents_sdk_mvp/workspace/.gitignore @@ -0,0 +1,4 @@ +# Ignore all files in workspace directory +# Each task gets its own subdirectory here +* +!.gitignore From 0108732f0e08eadc53bd6a70493937c45aec1e01 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 28 Nov 2025 05:23:46 +0000 Subject: [PATCH 0919/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From db0989a18e5e7f04929afcce5997b905a62db7c3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 28 Nov 2025 06:23:36 +0000 Subject: [PATCH 0920/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 22488f5d00bc747980e2616dd56455785ab5d4db Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 28 Nov 2025 07:23:34 +0000 Subject: [PATCH 0921/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e2b33d7386875eb04bf5d3be4aca1f5b74c5ffaf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 28 Nov 2025 09:23:55 +0000 Subject: [PATCH 0922/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 6736cf5e6da7982442c54b598acd26e939192c58 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 28 Nov 2025 10:23:36 +0000 Subject: [PATCH 0923/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 064a722472fcd8e969e4f6bc001aeb6fe9da4f7c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 28 Nov 2025 13:23:37 +0000 Subject: [PATCH 0924/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 52b55978b0337a584de82c6b3d00dfb89af4d382 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 28 Nov 2025 15:23:32 +0000 Subject: [PATCH 0925/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 8c7881abc1dfb0aee9a768f9f0ddad5039580466 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 28 Nov 2025 18:23:42 +0000 Subject: [PATCH 0926/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From d85ae5cf697af5ea1aa1dae9846fe8c246a7348a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 28 Nov 2025 19:23:35 +0000 Subject: [PATCH 0927/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 25f82500aaf44d198c9ab63fba0456ccff057565 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 28 Nov 2025 20:23:36 +0000 Subject: [PATCH 0928/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 455dc46c94382270574ad5c3b2c5a131c71e445b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 28 Nov 2025 22:23:35 +0000 Subject: [PATCH 0929/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 3b8e2c90513835e2c68576518a55887d793dcb31 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 28 Nov 2025 23:23:36 +0000 Subject: [PATCH 0930/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From d69466280d1dd0f1079be8b76c7f3c8716197ccb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 29 Nov 2025 01:23:32 +0000 Subject: [PATCH 0931/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c4fbe4bee48c2c5343161479c99049532a35ab96 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 29 Nov 2025 03:23:31 +0000 Subject: [PATCH 0932/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 51125e586392ab5ed8659292787e074082794471 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 29 Nov 2025 04:23:40 +0000 Subject: [PATCH 0933/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 5d75df56b1566028c54540201edddd1ae357d2b5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 29 Nov 2025 07:23:38 +0000 Subject: [PATCH 0934/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From d7be95d6a772bdfcb3409ee9d973552c811c9d9c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 29 Nov 2025 12:23:42 +0000 Subject: [PATCH 0935/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 0da5d801d0d62f1fc44c9ab81ca9f127b3803e7c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 29 Nov 2025 14:23:36 +0000 Subject: [PATCH 0936/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 392c10c6236d9b9cb4f535669da7727ab0f643fb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 29 Nov 2025 16:23:35 +0000 Subject: [PATCH 0937/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From dde294866ad600a5ef8c1383d49f976ef7ee4e69 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 29 Nov 2025 17:23:29 +0000 Subject: [PATCH 0938/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 57c8b3ca64c2900cbe68ed3bc3b57e8d24182326 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 29 Nov 2025 20:23:37 +0000 Subject: [PATCH 0939/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 50208a689bc3ba8f81e8e17dae689ccc60ba4bbc Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 29 Nov 2025 22:23:46 +0000 Subject: [PATCH 0940/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 9b0d3628a3451bb4d9c00b101f82e1ca98212cdb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 30 Nov 2025 00:23:43 +0000 Subject: [PATCH 0941/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From daf49210bee885c3928c30c86643aab7bd5296eb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 30 Nov 2025 02:23:38 +0000 Subject: [PATCH 0942/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 98a69ed896da51de8b45c887e03e110a4fc14933 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 30 Nov 2025 04:23:47 +0000 Subject: [PATCH 0943/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 0b7d47034890bfaf1b448aa0097266108695cb31 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 30 Nov 2025 14:23:45 +0000 Subject: [PATCH 0944/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From b6d7db7ccb39f3a806c119ecca68060aa884bc74 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 30 Nov 2025 15:23:46 +0000 Subject: [PATCH 0945/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From a2700221cc4f7035fdd3ccc2b2d5e46966f2a653 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 30 Nov 2025 17:23:47 +0000 Subject: [PATCH 0946/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 72eb1f2d1117d5ce6f806b961c8d5a1ab5ee6e6c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 30 Nov 2025 19:23:46 +0000 Subject: [PATCH 0947/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From aec3df45f2389db9dedd2cd15d24a0d4412b03c4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 30 Nov 2025 20:23:41 +0000 Subject: [PATCH 0948/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 42e6ad8ef1cbfe16ccb1042834a55701a2a29295 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 30 Nov 2025 22:23:32 +0000 Subject: [PATCH 0949/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 8c2ce554c40096a1f216992ae0b0e33cd762a570 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 30 Nov 2025 23:23:47 +0000 Subject: [PATCH 0950/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 32dfc2f447d010e504e591896ed57cacd9b3ca57 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 1 Dec 2025 00:23:36 +0000 Subject: [PATCH 0951/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From ea4e0111869255cef14f602eed9fd0f121c747a2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 1 Dec 2025 01:23:47 +0000 Subject: [PATCH 0952/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 7ca1258cbfd597386a18fd0ee81d95e3797c807f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 1 Dec 2025 03:23:48 +0000 Subject: [PATCH 0953/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 88d9a2586b46f21de678311ce281d4b6683a6a54 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 1 Dec 2025 04:23:36 +0000 Subject: [PATCH 0954/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From db67d7bf6276ef35f385eda8c66c98dde75bc10f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 1 Dec 2025 06:23:33 +0000 Subject: [PATCH 0955/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 65697e5551879137508fc627ef44c92736f8ac96 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 1 Dec 2025 08:23:31 +0000 Subject: [PATCH 0956/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From aad638109f7ce8e853d9e6cd02be363d3da35d0c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 1 Dec 2025 09:23:31 +0000 Subject: [PATCH 0957/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 2aad231cf413c6d3f54b7129387e7ad25f8e514a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 1 Dec 2025 10:23:47 +0000 Subject: [PATCH 0958/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 1742c7478748046d090c9604009d23031c3d0b88 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 1 Dec 2025 15:23:48 +0000 Subject: [PATCH 0959/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From ea48f1cf359561334b7c91703e46dd259e6e8d18 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 1 Dec 2025 17:23:33 +0000 Subject: [PATCH 0960/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 43b830f402a320b0cc1a694411d2929650aa65a9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 1 Dec 2025 18:23:27 +0000 Subject: [PATCH 0961/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From df86af0313f128ba1e38deb8287bf4f707b05941 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 1 Dec 2025 20:23:35 +0000 Subject: [PATCH 0962/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 9ebe79744e477862c3345f5642e03fb0446fd2de Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 1 Dec 2025 21:23:44 +0000 Subject: [PATCH 0963/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 45ba3122804154da3f3440af25228098b01a8792 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 1 Dec 2025 22:23:47 +0000 Subject: [PATCH 0964/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..5930243b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml +openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From bcd03b399891a005f68c90386463f66eb67a3f43 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 1 Dec 2025 23:23:35 +0000 Subject: [PATCH 0965/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5930243b..80991383 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-64ff64e20f2648f51bf21789085d249b3224e1c70939d68609adf32c4330cdf5.yml -openapi_spec_hash: d9d6d9955f8a9dec9f18f1eb6aab5498 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml +openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 93a0f9d32fa651bcd13c0a25c20ede77d14dc803 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 2 Dec 2025 01:32:07 +0000 Subject: [PATCH 0966/1108] feat(api): api update --- .stats.yml | 4 ++-- src/agentex/resources/messages/messages.py | 8 ++++++++ src/agentex/resources/states.py | 16 ++++++++++++++++ src/agentex/types/message_list_params.py | 5 +++++ src/agentex/types/state_list_params.py | 6 ++++++ tests/api_resources/test_messages.py | 4 ++++ tests/api_resources/test_states.py | 4 ++++ 7 files changed, 45 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 80991383..1dac83da 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-39ca5a9d5ad039fdfb4da53dd41edb496943e4c39f12f4778238dde170ff9b17.yml -openapi_spec_hash: 6f2f0d8c757d172254e346c647d27482 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml +openapi_spec_hash: 29e41b58277845bbb419d94055ae188a config_hash: 0197f86ba1a4b1b5ce813d0e62138588 diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index 84537bca..401acccb 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -181,6 +181,8 @@ def list( *, task_id: str, limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, page_number: int | 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. @@ -214,6 +216,8 @@ def list( { "task_id": task_id, "limit": limit, + "order_by": order_by, + "order_direction": order_direction, "page_number": page_number, }, message_list_params.MessageListParams, @@ -370,6 +374,8 @@ async def list( *, task_id: str, limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, page_number: int | 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. @@ -403,6 +409,8 @@ async def list( { "task_id": task_id, "limit": limit, + "order_by": order_by, + "order_direction": order_direction, "page_number": page_number, }, message_list_params.MessageListParams, diff --git a/src/agentex/resources/states.py b/src/agentex/resources/states.py index 8642317e..a8f3d085 100644 --- a/src/agentex/resources/states.py +++ b/src/agentex/resources/states.py @@ -167,6 +167,8 @@ def list( *, agent_id: Optional[str] | Omit = omit, limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, page_number: int | Omit = omit, task_id: Optional[str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -184,6 +186,10 @@ def list( limit: Limit + order_by: Field to order by + + order_direction: Order direction (asc or desc) + page_number: Page number task_id: Task ID @@ -207,6 +213,8 @@ def list( { "agent_id": agent_id, "limit": limit, + "order_by": order_by, + "order_direction": order_direction, "page_number": page_number, "task_id": task_id, }, @@ -393,6 +401,8 @@ async def list( *, agent_id: Optional[str] | Omit = omit, limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, page_number: int | Omit = omit, task_id: Optional[str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -410,6 +420,10 @@ async def list( limit: Limit + order_by: Field to order by + + order_direction: Order direction (asc or desc) + page_number: Page number task_id: Task ID @@ -433,6 +447,8 @@ async def list( { "agent_id": agent_id, "limit": limit, + "order_by": order_by, + "order_direction": order_direction, "page_number": page_number, "task_id": task_id, }, diff --git a/src/agentex/types/message_list_params.py b/src/agentex/types/message_list_params.py index 977972e3..87027eed 100644 --- a/src/agentex/types/message_list_params.py +++ b/src/agentex/types/message_list_params.py @@ -2,6 +2,7 @@ from __future__ import annotations +from typing import Optional from typing_extensions import Required, TypedDict __all__ = ["MessageListParams"] @@ -13,4 +14,8 @@ class MessageListParams(TypedDict, total=False): limit: int + order_by: Optional[str] + + order_direction: str + page_number: int diff --git a/src/agentex/types/state_list_params.py b/src/agentex/types/state_list_params.py index 9a52c152..9cb7d3dc 100644 --- a/src/agentex/types/state_list_params.py +++ b/src/agentex/types/state_list_params.py @@ -15,6 +15,12 @@ class StateListParams(TypedDict, total=False): limit: int """Limit""" + order_by: Optional[str] + """Field to order by""" + + order_direction: str + """Order direction (asc or desc)""" + page_number: int """Page number""" diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py index f8d83bc2..ac2ccc16 100644 --- a/tests/api_resources/test_messages.py +++ b/tests/api_resources/test_messages.py @@ -240,6 +240,8 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: message = client.messages.list( task_id="task_id", limit=0, + order_by="order_by", + order_direction="order_direction", page_number=0, ) assert_matches_type(MessageListResponse, message, path=["response"]) @@ -496,6 +498,8 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> message = await async_client.messages.list( task_id="task_id", limit=0, + order_by="order_by", + order_direction="order_direction", page_number=0, ) assert_matches_type(MessageListResponse, message, path=["response"]) diff --git a/tests/api_resources/test_states.py b/tests/api_resources/test_states.py index e5b74172..c8cfd84c 100644 --- a/tests/api_resources/test_states.py +++ b/tests/api_resources/test_states.py @@ -165,6 +165,8 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: state = client.states.list( agent_id="agent_id", limit=1, + order_by="order_by", + order_direction="order_direction", page_number=1, task_id="task_id", ) @@ -388,6 +390,8 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> state = await async_client.states.list( agent_id="agent_id", limit=1, + order_by="order_by", + order_direction="order_direction", page_number=1, task_id="task_id", ) From 31925b88b7ac67c18b4db198748cf26342875922 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 2 Dec 2025 02:32:12 +0000 Subject: [PATCH 0967/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1dac83da..9e06cfcb 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml -openapi_spec_hash: 29e41b58277845bbb419d94055ae188a +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml +openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From fd700bd70a0c34e7310e90a8011ed9d653d574e9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 2 Dec 2025 03:32:16 +0000 Subject: [PATCH 0968/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9e06cfcb..1dac83da 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml -openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml +openapi_spec_hash: 29e41b58277845bbb419d94055ae188a config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 75676e6f6ca44c4ae582705602f6804db6538374 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 2 Dec 2025 04:32:17 +0000 Subject: [PATCH 0969/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1dac83da..9e06cfcb 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml -openapi_spec_hash: 29e41b58277845bbb419d94055ae188a +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml +openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From f37fd8c065c1721918158aa499bbc5866c8d9713 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 2 Dec 2025 05:32:19 +0000 Subject: [PATCH 0970/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9e06cfcb..1dac83da 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml -openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml +openapi_spec_hash: 29e41b58277845bbb419d94055ae188a config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 18330e2541ca79a5f093de19834a38e84cc004cf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 2 Dec 2025 08:32:26 +0000 Subject: [PATCH 0971/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1dac83da..9e06cfcb 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml -openapi_spec_hash: 29e41b58277845bbb419d94055ae188a +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml +openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From fc1c60ddccbc9f01bdbba4387341a8c1443fd833 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 2 Dec 2025 09:32:14 +0000 Subject: [PATCH 0972/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9e06cfcb..1dac83da 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml -openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml +openapi_spec_hash: 29e41b58277845bbb419d94055ae188a config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 0f2ed547e2e0351d428cca52554b86b876aaeb0b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 2 Dec 2025 11:09:39 +0000 Subject: [PATCH 0973/1108] chore: update lockfile --- pyproject.toml | 14 +++--- requirements-dev.lock | 108 +++++++++++++++++++++++------------------- requirements.lock | 31 ++++++------ 3 files changed, 83 insertions(+), 70 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 4abe57e0..16017ae3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,14 +7,16 @@ license = "Apache-2.0" authors = [ { name = "Agentex", email = "roxanne.farhad@scale.com" }, ] + dependencies = [ - "httpx>=0.23.0, <1", - "pydantic>=1.9.0, <3", - "typing-extensions>=4.10, <5", - "anyio>=3.5.0, <5", - "distro>=1.7.0, <2", - "sniffio", + "httpx>=0.23.0, <1", + "pydantic>=1.9.0, <3", + "typing-extensions>=4.10, <5", + "anyio>=3.5.0, <5", + "distro>=1.7.0, <2", + "sniffio", ] + requires-python = ">= 3.9" classifiers = [ "Typing :: Typed", diff --git a/requirements-dev.lock b/requirements-dev.lock index 097694b9..8debae92 100644 --- a/requirements-dev.lock +++ b/requirements-dev.lock @@ -12,40 +12,45 @@ -e file:. aiohappyeyeballs==2.6.1 # via aiohttp -aiohttp==3.12.8 +aiohttp==3.13.2 # via agentex-sdk # via httpx-aiohttp -aiosignal==1.3.2 +aiosignal==1.4.0 # via aiohttp -annotated-types==0.6.0 +annotated-types==0.7.0 # via pydantic -anyio==4.4.0 +anyio==4.12.0 # via agentex-sdk # via httpx -argcomplete==3.1.2 +argcomplete==3.6.3 # via nox async-timeout==5.0.1 # via aiohttp -attrs==25.3.0 +attrs==25.4.0 # via aiohttp -certifi==2023.7.22 + # via nox +backports-asyncio-runner==1.2.0 + # via pytest-asyncio +certifi==2025.11.12 # via httpcore # via httpx -colorlog==6.7.0 +colorlog==6.10.1 + # via nox +dependency-groups==1.3.1 # via nox -dirty-equals==0.6.0 -distlib==0.3.7 +dirty-equals==0.11 +distlib==0.4.0 # via virtualenv -distro==1.8.0 +distro==1.9.0 # via agentex-sdk -exceptiongroup==1.2.2 +exceptiongroup==1.3.1 # via anyio # via pytest -execnet==2.1.1 +execnet==2.1.2 # via pytest-xdist -filelock==3.12.4 +filelock==3.19.1 # via virtualenv -frozenlist==1.6.2 +frozenlist==1.8.0 # via aiohttp # via aiosignal h11==0.16.0 @@ -58,82 +63,87 @@ httpx==0.28.1 # via respx httpx-aiohttp==0.1.9 # via agentex-sdk -idna==3.4 +humanize==4.13.0 + # via nox +idna==3.11 # via anyio # via httpx # via yarl -importlib-metadata==7.0.0 -iniconfig==2.0.0 +importlib-metadata==8.7.0 +iniconfig==2.1.0 # via pytest markdown-it-py==3.0.0 # via rich mdurl==0.1.2 # via markdown-it-py -multidict==6.4.4 +multidict==6.7.0 # via aiohttp # via yarl mypy==1.17.0 -mypy-extensions==1.0.0 +mypy-extensions==1.1.0 # via mypy -nodeenv==1.8.0 +nodeenv==1.9.1 # via pyright -nox==2023.4.22 -packaging==23.2 +nox==2025.11.12 +packaging==25.0 + # via dependency-groups # via nox # via pytest pathspec==0.12.1 # via mypy -platformdirs==3.11.0 +platformdirs==4.4.0 # via virtualenv -pluggy==1.5.0 +pluggy==1.6.0 # via pytest -propcache==0.3.1 +propcache==0.4.1 # via aiohttp # via yarl -pydantic==2.11.9 +pydantic==2.12.5 # via agentex-sdk -pydantic-core==2.33.2 +pydantic-core==2.41.5 # via pydantic -pygments==2.18.0 +pygments==2.19.2 + # via pytest # via rich pyright==1.1.399 -pytest==8.3.3 +pytest==8.4.2 # via pytest-asyncio # via pytest-xdist -pytest-asyncio==0.24.0 -pytest-xdist==3.7.0 -python-dateutil==2.8.2 +pytest-asyncio==1.2.0 +pytest-xdist==3.8.0 +python-dateutil==2.9.0.post0 # via time-machine -pytz==2023.3.post1 - # via dirty-equals respx==0.22.0 -rich==13.7.1 -ruff==0.9.4 -setuptools==68.2.2 - # via nodeenv -six==1.16.0 +rich==14.2.0 +ruff==0.14.7 +six==1.17.0 # via python-dateutil -sniffio==1.3.0 +sniffio==1.3.1 # via agentex-sdk - # via anyio -time-machine==2.9.0 -tomli==2.0.2 +time-machine==2.19.0 +tomli==2.3.0 + # via dependency-groups # via mypy + # via nox # via pytest -typing-extensions==4.12.2 +typing-extensions==4.15.0 # via agentex-sdk + # via aiosignal # via anyio + # via exceptiongroup # via multidict # via mypy # via pydantic # via pydantic-core # via pyright + # via pytest-asyncio # via typing-inspection -typing-inspection==0.4.1 + # via virtualenv +typing-inspection==0.4.2 # via pydantic -virtualenv==20.24.5 +virtualenv==20.35.4 # via nox -yarl==1.20.0 +yarl==1.22.0 # via aiohttp -zipp==3.17.0 +zipp==3.23.0 # via importlib-metadata diff --git a/requirements.lock b/requirements.lock index 3249fd77..27f5fe33 100644 --- a/requirements.lock +++ b/requirements.lock @@ -12,28 +12,28 @@ -e file:. aiohappyeyeballs==2.6.1 # via aiohttp -aiohttp==3.12.8 +aiohttp==3.13.2 # via agentex-sdk # via httpx-aiohttp -aiosignal==1.3.2 +aiosignal==1.4.0 # via aiohttp -annotated-types==0.6.0 +annotated-types==0.7.0 # via pydantic -anyio==4.4.0 +anyio==4.12.0 # via agentex-sdk # via httpx async-timeout==5.0.1 # via aiohttp -attrs==25.3.0 +attrs==25.4.0 # via aiohttp -certifi==2023.7.22 +certifi==2025.11.12 # via httpcore # via httpx -distro==1.8.0 +distro==1.9.0 # via agentex-sdk -exceptiongroup==1.2.2 +exceptiongroup==1.3.1 # via anyio -frozenlist==1.6.2 +frozenlist==1.8.0 # via aiohttp # via aiosignal h11==0.16.0 @@ -45,31 +45,32 @@ httpx==0.28.1 # via httpx-aiohttp httpx-aiohttp==0.1.9 # via agentex-sdk -idna==3.4 +idna==3.11 # via anyio # via httpx # via yarl -multidict==6.4.4 +multidict==6.7.0 # via aiohttp # via yarl -propcache==0.3.1 +propcache==0.4.1 # via aiohttp # via yarl pydantic==2.12.5 # via agentex-sdk pydantic-core==2.41.5 # via pydantic -sniffio==1.3.0 +sniffio==1.3.1 # via agentex-sdk - # via anyio typing-extensions==4.15.0 # via agentex-sdk + # via aiosignal # via anyio + # via exceptiongroup # via multidict # via pydantic # via pydantic-core # via typing-inspection typing-inspection==0.4.2 # via pydantic -yarl==1.20.0 +yarl==1.22.0 # via aiohttp From a06555a77044eba53de9a079f9fb2cbdc0ebfe7f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 2 Dec 2025 11:32:26 +0000 Subject: [PATCH 0974/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1dac83da..9e06cfcb 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml -openapi_spec_hash: 29e41b58277845bbb419d94055ae188a +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml +openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c7e0e45df59b657078b5e013db3483b0ac94744f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 2 Dec 2025 18:32:09 +0000 Subject: [PATCH 0975/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9e06cfcb..1dac83da 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml -openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml +openapi_spec_hash: 29e41b58277845bbb419d94055ae188a config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From d784cb8b1601475d2c170b6eff713e2476a4001e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 2 Dec 2025 20:32:39 +0000 Subject: [PATCH 0976/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1dac83da..9e06cfcb 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml -openapi_spec_hash: 29e41b58277845bbb419d94055ae188a +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml +openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 84c6ffc048979bef71d619f92dedeb9f2c026e26 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 2 Dec 2025 21:26:14 +0000 Subject: [PATCH 0977/1108] chore(docs): use environment variables for authentication in code snippets --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index ae6a4d16..44d302aa 100644 --- a/README.md +++ b/README.md @@ -81,6 +81,7 @@ pip install agentex-sdk[aiohttp] Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`: ```python +import os import asyncio from agentex import DefaultAioHttpClient from agentex import AsyncAgentex @@ -88,7 +89,7 @@ from agentex import AsyncAgentex async def main() -> None: async with AsyncAgentex( - api_key="My API Key", + api_key=os.environ.get("AGENTEX_SDK_API_KEY"), # This is the default and can be omitted http_client=DefaultAioHttpClient(), ) as client: tasks = await client.tasks.list() From aea4a8d0d9d0a19d59ede666a008ec45ee4770e4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 2 Dec 2025 21:33:06 +0000 Subject: [PATCH 0978/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9e06cfcb..1dac83da 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml -openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml +openapi_spec_hash: 29e41b58277845bbb419d94055ae188a config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 0055e6d496dc595b3e281c0c098ea86ba91079b8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 2 Dec 2025 22:32:02 +0000 Subject: [PATCH 0979/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1dac83da..9e06cfcb 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml -openapi_spec_hash: 29e41b58277845bbb419d94055ae188a +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml +openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 754d6135b33aad69f30e97e7f8c4b06ee7b7970f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Dec 2025 00:31:56 +0000 Subject: [PATCH 0980/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9e06cfcb..1dac83da 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml -openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml +openapi_spec_hash: 29e41b58277845bbb419d94055ae188a config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 3dc73f73a2eafcbfdd93cb4525233a71b2b1c8a3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Dec 2025 01:31:57 +0000 Subject: [PATCH 0981/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1dac83da..9e06cfcb 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml -openapi_spec_hash: 29e41b58277845bbb419d94055ae188a +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml +openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 54bee166aa0c7b6b11f2fe68b768101eeb1d13ab Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Dec 2025 03:32:02 +0000 Subject: [PATCH 0982/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9e06cfcb..1dac83da 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml -openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml +openapi_spec_hash: 29e41b58277845bbb419d94055ae188a config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 6edf479f687b94c9b62c2873fe9c26617cd4796e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Dec 2025 04:32:04 +0000 Subject: [PATCH 0983/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1dac83da..9e06cfcb 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml -openapi_spec_hash: 29e41b58277845bbb419d94055ae188a +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml +openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From f298f0a6cfbcd1c485cc5adbc784f65ec42d116a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Dec 2025 05:32:09 +0000 Subject: [PATCH 0984/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9e06cfcb..1dac83da 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml -openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml +openapi_spec_hash: 29e41b58277845bbb419d94055ae188a config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From f16aebd50674c424ee66890b46f792bee8baffaf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Dec 2025 06:32:07 +0000 Subject: [PATCH 0985/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1dac83da..9e06cfcb 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml -openapi_spec_hash: 29e41b58277845bbb419d94055ae188a +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml +openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 16f93567054f3608d33e08c4ddeb8cf05af44e04 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Dec 2025 09:32:24 +0000 Subject: [PATCH 0986/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9e06cfcb..1dac83da 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml -openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml +openapi_spec_hash: 29e41b58277845bbb419d94055ae188a config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 9c608772b17ce2055503c4400275c38ce33741c6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Dec 2025 10:32:26 +0000 Subject: [PATCH 0987/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1dac83da..9e06cfcb 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml -openapi_spec_hash: 29e41b58277845bbb419d94055ae188a +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml +openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c0a0671f3bfa16f0871d31d7020b609c98ad08b4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Dec 2025 11:32:26 +0000 Subject: [PATCH 0988/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9e06cfcb..1dac83da 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml -openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml +openapi_spec_hash: 29e41b58277845bbb419d94055ae188a config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From acd9f656ef9d76e13ebd3d313a7d1af399f5e603 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Dec 2025 14:32:26 +0000 Subject: [PATCH 0989/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1dac83da..9e06cfcb 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml -openapi_spec_hash: 29e41b58277845bbb419d94055ae188a +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml +openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 1a021dfd59df97d80534c5a104490138f55db5c6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Dec 2025 16:33:02 +0000 Subject: [PATCH 0990/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9e06cfcb..1dac83da 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml -openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml +openapi_spec_hash: 29e41b58277845bbb419d94055ae188a config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 2c73eed789170c3c2af02e27f4f704666e8fecce Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Dec 2025 17:31:56 +0000 Subject: [PATCH 0991/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1dac83da..9e06cfcb 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml -openapi_spec_hash: 29e41b58277845bbb419d94055ae188a +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml +openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 3cc93a473030aeffef32abee49fb25b450bc68cf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Dec 2025 20:32:04 +0000 Subject: [PATCH 0992/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9e06cfcb..1dac83da 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml -openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml +openapi_spec_hash: 29e41b58277845bbb419d94055ae188a config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From de576ca42b6a89631b6cffa2dff4e421662b9eeb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Dec 2025 21:32:12 +0000 Subject: [PATCH 0993/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1dac83da..9e06cfcb 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-4a9fe0fbe18b82a7ada2b8845b3a14d37c5b01e942ba9c0e8f60330ceada1cf4.yml -openapi_spec_hash: 29e41b58277845bbb419d94055ae188a +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml +openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 89f2434f70ce580f12aa5589f3632133c18a542c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 3 Dec 2025 22:32:14 +0000 Subject: [PATCH 0994/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 9e06cfcb..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2a2d390ec403478ae115e1e5b32883f955cfb922a9e51a44b8a6b3d932748ca8.yml -openapi_spec_hash: f36932fc3bb6893c5eccb83d8cc1478c +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e6b10447b5bc216d800e0187107735332eaa7b94 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Dec 2025 00:32:28 +0000 Subject: [PATCH 0995/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 5faabde6af6ad156fdf36b7237da18e413c6752d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Dec 2025 02:32:08 +0000 Subject: [PATCH 0996/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From a286a870891d142a43abfe25d55322d8dfea328e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Dec 2025 05:32:07 +0000 Subject: [PATCH 0997/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 99070426e65cce2db5388c1e9f74a53bc181aea8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Dec 2025 07:31:58 +0000 Subject: [PATCH 0998/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 60531bd051a957bbc08ce98fe440c5fc9c1ffd30 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Dec 2025 08:32:08 +0000 Subject: [PATCH 0999/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 30a9284aaaa9acae5cfbe026fa17961a301eaf05 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Dec 2025 09:32:16 +0000 Subject: [PATCH 1000/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 1a8c43d0a4f08e130f062d5293933e25e26f756b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Dec 2025 10:32:19 +0000 Subject: [PATCH 1001/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c4f306c2c7957452abdde53670adfca4eee9b113 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Dec 2025 11:32:15 +0000 Subject: [PATCH 1002/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 8490430bbd9eb57fcf43e3fd61045340c9ba9c3f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Dec 2025 13:31:59 +0000 Subject: [PATCH 1003/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e982eeddfc610284a9f19882b51716bdbbf83317 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Dec 2025 16:32:09 +0000 Subject: [PATCH 1004/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 56ee9c391b5b7b58fd96f29105c91929da75a0bb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Dec 2025 18:32:53 +0000 Subject: [PATCH 1005/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 03ef57dc81d0c51367ffa25bcbf49ee39f82a9cb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Dec 2025 20:32:30 +0000 Subject: [PATCH 1006/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 09b9e6fc683aa7348c715f275cd59d6caf6de3f0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Dec 2025 22:32:15 +0000 Subject: [PATCH 1007/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 43187134a27a3877485593e254617e2348f112f2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 5 Dec 2025 00:32:29 +0000 Subject: [PATCH 1008/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From df5939208295d211983bb6b10a35766dd4120ce8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 5 Dec 2025 01:32:11 +0000 Subject: [PATCH 1009/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 66bc7a366c62c3355579bff2ad35807312b739dd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 5 Dec 2025 02:32:13 +0000 Subject: [PATCH 1010/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 241b4e72bacd048bd1dba15930cd175d389db514 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 5 Dec 2025 05:32:04 +0000 Subject: [PATCH 1011/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c54ac4b69d176195b651483bdfc376a8d8966436 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 5 Dec 2025 06:32:18 +0000 Subject: [PATCH 1012/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 1fb50e546a74b9af588ff8fb738b911ec6bec9ea Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 5 Dec 2025 09:31:57 +0000 Subject: [PATCH 1013/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 501441017aa1c14555167ddcf09f0cf7f7db51ea Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 5 Dec 2025 10:32:08 +0000 Subject: [PATCH 1014/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From ea0fe079c5fef93cc5d34f5d5125d5b15410436b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 5 Dec 2025 11:32:06 +0000 Subject: [PATCH 1015/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 5237ea3b383c58501a8bae9df473c7b7d1a13d16 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 5 Dec 2025 13:32:11 +0000 Subject: [PATCH 1016/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 4879a8e648f4f5c43912e39a63c585450e7617fb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 5 Dec 2025 17:32:13 +0000 Subject: [PATCH 1017/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From febf6d8a1254474657f4728e5dc90989da371f8a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 5 Dec 2025 18:32:14 +0000 Subject: [PATCH 1018/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e6e3562e70eda469278633e522047eb9833ee38a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 5 Dec 2025 21:32:02 +0000 Subject: [PATCH 1019/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From dcd27739a59585d1f432b4a75acfca9b2d494c0d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 5 Dec 2025 23:37:13 +0000 Subject: [PATCH 1020/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 38f900d9dafc81c8c6041f0bb100296e998f0679 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 6 Dec 2025 00:32:01 +0000 Subject: [PATCH 1021/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 70ed43bbb7a558463cbae45808caae8d31bbc553 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 6 Dec 2025 01:32:01 +0000 Subject: [PATCH 1022/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From b13f9c1465d24ddf19c050d97c7f5bdd88b3add1 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 6 Dec 2025 02:32:06 +0000 Subject: [PATCH 1023/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 7d5850d93d20bd71df3da0d02d1c7342ce55e9fa Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 6 Dec 2025 03:31:50 +0000 Subject: [PATCH 1024/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 1d54d67fef1afe9a80814ce0594065d3c2057aea Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 6 Dec 2025 05:31:56 +0000 Subject: [PATCH 1025/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 48b749781a8c01c44170b72a9c252186d4d5a729 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 6 Dec 2025 07:32:00 +0000 Subject: [PATCH 1026/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 9e7d0e77a145ff6758e1f73bc55863f0d9ee4ef7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 6 Dec 2025 12:32:23 +0000 Subject: [PATCH 1027/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 8e8b25d1fe24974f31b99bae229970296484cb89 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 6 Dec 2025 13:32:10 +0000 Subject: [PATCH 1028/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e9323930691e8f80761d88d4496521269d192bb9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 6 Dec 2025 16:32:02 +0000 Subject: [PATCH 1029/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 9fe79d28b8c78a51f8e0c7cce38d7437ec7c1c8f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 6 Dec 2025 17:32:02 +0000 Subject: [PATCH 1030/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 4888bfb0da55f282e8398650ba256d1eadf9798f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 6 Dec 2025 19:32:19 +0000 Subject: [PATCH 1031/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From d4f3021aa599d559256830eee486f63730fc757b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 6 Dec 2025 21:32:07 +0000 Subject: [PATCH 1032/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From d00c7f0cd213fac32ab9a657886ac871acfe3838 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 6 Dec 2025 23:32:07 +0000 Subject: [PATCH 1033/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 5af0da9fddb05e150a3f2c5f143e85816fea7ec7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 7 Dec 2025 01:32:24 +0000 Subject: [PATCH 1034/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 3aa21473eca50419966d574acaefdae2da0ff5e5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 7 Dec 2025 02:32:19 +0000 Subject: [PATCH 1035/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 421139c354ef973c87492f468045c10db8207c56 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 7 Dec 2025 03:32:18 +0000 Subject: [PATCH 1036/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 43d84f67e9168a2a88e0cd8a745d8e22d13456c2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 7 Dec 2025 10:32:20 +0000 Subject: [PATCH 1037/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From a2eea58f13297cd588211bf44d65590fbe6fa243 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 7 Dec 2025 13:32:17 +0000 Subject: [PATCH 1038/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From e722d5aac83b12f9e698a67b93e6247998be5d61 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 7 Dec 2025 17:32:12 +0000 Subject: [PATCH 1039/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From c112812e530b87af3366c52c8094018c32197308 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 7 Dec 2025 18:32:06 +0000 Subject: [PATCH 1040/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 7239a948782687ee0bf42d435c9ed13f635c9f68 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 7 Dec 2025 20:32:00 +0000 Subject: [PATCH 1041/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From ff9f12b014c373d090c6de2d4ed5335a56750c39 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 8 Dec 2025 02:32:08 +0000 Subject: [PATCH 1042/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 987d105863cbbcf0909c106908b5f0baf55f1fde Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 8 Dec 2025 03:32:12 +0000 Subject: [PATCH 1043/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 46b3bb4584ce3940a6db26fd2e467619975c6fcd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 8 Dec 2025 04:32:12 +0000 Subject: [PATCH 1044/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From db514ff9806acd484a5f48e8d54fdda9aa9dfe7b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 8 Dec 2025 06:32:06 +0000 Subject: [PATCH 1045/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From a523cab5b49c8cc2cd3f04e9ddd513fe37b58460 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 8 Dec 2025 11:32:22 +0000 Subject: [PATCH 1046/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 08aa0697145fcb5853d2793608c5506e71158ebd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 8 Dec 2025 14:32:00 +0000 Subject: [PATCH 1047/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..6c495f32 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From d44c408ac2e532c19a3f65a8cfe6fe23d2df38c0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 8 Dec 2025 15:32:18 +0000 Subject: [PATCH 1048/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 6c495f32..783a2c01 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 0197f86ba1a4b1b5ce813d0e62138588 From 6f8501abe4fffb4c4798915726262d98197cc20a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 8 Dec 2025 18:43:35 +0000 Subject: [PATCH 1049/1108] fix(types): allow pyright to infer TypedDict types within SequenceNotStr --- src/agentex/_types.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/agentex/_types.py b/src/agentex/_types.py index e546d27f..e0fccac6 100644 --- a/src/agentex/_types.py +++ b/src/agentex/_types.py @@ -243,6 +243,9 @@ class HttpxSendArgs(TypedDict, total=False): if TYPE_CHECKING: # This works because str.__contains__ does not accept object (either in typeshed or at runtime) # https://github.com/hauntsaninja/useful_types/blob/5e9710f3875107d068e7679fd7fec9cfab0eff3b/useful_types/__init__.py#L285 + # + # Note: index() and count() methods are intentionally omitted to allow pyright to properly + # infer TypedDict types when dict literals are used in lists assigned to SequenceNotStr. class SequenceNotStr(Protocol[_T_co]): @overload def __getitem__(self, index: SupportsIndex, /) -> _T_co: ... @@ -251,8 +254,6 @@ def __getitem__(self, index: slice, /) -> Sequence[_T_co]: ... def __contains__(self, value: object, /) -> bool: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[_T_co]: ... - def index(self, value: Any, start: int = 0, stop: int = ..., /) -> int: ... - def count(self, value: Any, /) -> int: ... def __reversed__(self) -> Iterator[_T_co]: ... else: # just point this to a normal `Sequence` at runtime to avoid having to special case From 126e26357cd3060f51ae7c62b0089604a1077a9e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 8 Dec 2025 19:30:29 +0000 Subject: [PATCH 1050/1108] chore: add missing docstrings --- src/agentex/types/agent_rpc_result.py | 8 ++++++++ src/agentex/types/data_delta.py | 2 ++ src/agentex/types/reasoning_content_delta.py | 2 ++ src/agentex/types/reasoning_summary_delta.py | 2 ++ src/agentex/types/state.py | 10 ++++++++++ src/agentex/types/task_list_response.py | 2 ++ src/agentex/types/task_message.py | 6 ++++++ src/agentex/types/task_message_update.py | 8 ++++++++ src/agentex/types/task_retrieve_by_name_response.py | 2 ++ src/agentex/types/task_retrieve_response.py | 2 ++ src/agentex/types/text_content.py | 2 ++ src/agentex/types/text_content_param.py | 2 ++ src/agentex/types/text_delta.py | 2 ++ src/agentex/types/tool_request_delta.py | 2 ++ src/agentex/types/tool_response_delta.py | 2 ++ 15 files changed, 54 insertions(+) diff --git a/src/agentex/types/agent_rpc_result.py b/src/agentex/types/agent_rpc_result.py index 63e30a5d..d8a0ead8 100644 --- a/src/agentex/types/agent_rpc_result.py +++ b/src/agentex/types/agent_rpc_result.py @@ -20,6 +20,8 @@ class StreamTaskMessageStart(BaseModel): + """Event for starting a streaming message""" + content: TaskMessageContent index: Optional[int] = None @@ -35,6 +37,8 @@ class StreamTaskMessageStart(BaseModel): class StreamTaskMessageDelta(BaseModel): + """Event for streaming chunks of content""" + delta: Optional[TaskMessageDelta] = None """Delta for text updates""" @@ -51,6 +55,8 @@ class StreamTaskMessageDelta(BaseModel): class StreamTaskMessageFull(BaseModel): + """Event for streaming the full content""" + content: TaskMessageContent index: Optional[int] = None @@ -66,6 +72,8 @@ class StreamTaskMessageFull(BaseModel): class StreamTaskMessageDone(BaseModel): + """Event for indicating the task is done""" + index: Optional[int] = None parent_task_message: Optional[TaskMessage] = None diff --git a/src/agentex/types/data_delta.py b/src/agentex/types/data_delta.py index e30c12e7..5b15838a 100644 --- a/src/agentex/types/data_delta.py +++ b/src/agentex/types/data_delta.py @@ -9,6 +9,8 @@ class DataDelta(BaseModel): + """Delta for data updates""" + data_delta: Optional[str] = None type: Optional[Literal["data"]] = None diff --git a/src/agentex/types/reasoning_content_delta.py b/src/agentex/types/reasoning_content_delta.py index ae79ca8a..8a3e2a88 100644 --- a/src/agentex/types/reasoning_content_delta.py +++ b/src/agentex/types/reasoning_content_delta.py @@ -9,6 +9,8 @@ class ReasoningContentDelta(BaseModel): + """Delta for reasoning content updates""" + content_index: int content_delta: Optional[str] = None diff --git a/src/agentex/types/reasoning_summary_delta.py b/src/agentex/types/reasoning_summary_delta.py index 607cbec2..f12a12e3 100644 --- a/src/agentex/types/reasoning_summary_delta.py +++ b/src/agentex/types/reasoning_summary_delta.py @@ -9,6 +9,8 @@ class ReasoningSummaryDelta(BaseModel): + """Delta for reasoning summary updates""" + summary_index: int summary_delta: Optional[str] = None diff --git a/src/agentex/types/state.py b/src/agentex/types/state.py index 2789c7c3..f0d919b7 100644 --- a/src/agentex/types/state.py +++ b/src/agentex/types/state.py @@ -9,6 +9,16 @@ class State(BaseModel): + """Represents a state in the agent system. + + A state is associated uniquely with a task and an agent. + + This entity is used to store states in MongoDB, with each state + associated with a specific task and agent. The combination of task_id and agent_id is globally unique. + + The state is a dictionary of arbitrary data. + """ + id: str """The task state's unique id""" diff --git a/src/agentex/types/task_list_response.py b/src/agentex/types/task_list_response.py index 745c9fbe..85f87c0e 100644 --- a/src/agentex/types/task_list_response.py +++ b/src/agentex/types/task_list_response.py @@ -11,6 +11,8 @@ class TaskListResponseItem(BaseModel): + """Task response model with optional related data based on relationships""" + id: str agents: Optional[List[Agent]] = None diff --git a/src/agentex/types/task_message.py b/src/agentex/types/task_message.py index b5938cc8..1f78e925 100644 --- a/src/agentex/types/task_message.py +++ b/src/agentex/types/task_message.py @@ -11,6 +11,12 @@ class TaskMessage(BaseModel): + """Represents a message in the agent system. + + This entity is used to store messages in MongoDB, with each message + associated with a specific task. + """ + content: TaskMessageContent """The content of the message. diff --git a/src/agentex/types/task_message_update.py b/src/agentex/types/task_message_update.py index 13e1e821..05ad128c 100644 --- a/src/agentex/types/task_message_update.py +++ b/src/agentex/types/task_message_update.py @@ -19,6 +19,8 @@ class StreamTaskMessageStart(BaseModel): + """Event for starting a streaming message""" + content: TaskMessageContent index: Optional[int] = None @@ -34,6 +36,8 @@ class StreamTaskMessageStart(BaseModel): class StreamTaskMessageDelta(BaseModel): + """Event for streaming chunks of content""" + delta: Optional[TaskMessageDelta] = None """Delta for text updates""" @@ -50,6 +54,8 @@ class StreamTaskMessageDelta(BaseModel): class StreamTaskMessageFull(BaseModel): + """Event for streaming the full content""" + content: TaskMessageContent index: Optional[int] = None @@ -65,6 +71,8 @@ class StreamTaskMessageFull(BaseModel): class StreamTaskMessageDone(BaseModel): + """Event for indicating the task is done""" + index: Optional[int] = None parent_task_message: Optional[TaskMessage] = None diff --git a/src/agentex/types/task_retrieve_by_name_response.py b/src/agentex/types/task_retrieve_by_name_response.py index 4d8ae95d..1ffc6819 100644 --- a/src/agentex/types/task_retrieve_by_name_response.py +++ b/src/agentex/types/task_retrieve_by_name_response.py @@ -11,6 +11,8 @@ class TaskRetrieveByNameResponse(BaseModel): + """Task response model with optional related data based on relationships""" + id: str agents: Optional[List[Agent]] = None diff --git a/src/agentex/types/task_retrieve_response.py b/src/agentex/types/task_retrieve_response.py index f824b368..5f262946 100644 --- a/src/agentex/types/task_retrieve_response.py +++ b/src/agentex/types/task_retrieve_response.py @@ -11,6 +11,8 @@ class TaskRetrieveResponse(BaseModel): + """Task response model with optional related data based on relationships""" + id: str agents: Optional[List[Agent]] = None diff --git a/src/agentex/types/text_content.py b/src/agentex/types/text_content.py index d664b7e7..35fefb06 100644 --- a/src/agentex/types/text_content.py +++ b/src/agentex/types/text_content.py @@ -12,6 +12,8 @@ class Attachment(BaseModel): + """Represents a file attachment in messages.""" + file_id: str """The unique ID of the attached file""" diff --git a/src/agentex/types/text_content_param.py b/src/agentex/types/text_content_param.py index 9923a2a8..5415d9c4 100644 --- a/src/agentex/types/text_content_param.py +++ b/src/agentex/types/text_content_param.py @@ -13,6 +13,8 @@ class Attachment(TypedDict, total=False): + """Represents a file attachment in messages.""" + file_id: Required[str] """The unique ID of the attached file""" diff --git a/src/agentex/types/text_delta.py b/src/agentex/types/text_delta.py index 29a60cfd..def7cf91 100644 --- a/src/agentex/types/text_delta.py +++ b/src/agentex/types/text_delta.py @@ -9,6 +9,8 @@ class TextDelta(BaseModel): + """Delta for text updates""" + text_delta: Optional[str] = None type: Optional[Literal["text"]] = None diff --git a/src/agentex/types/tool_request_delta.py b/src/agentex/types/tool_request_delta.py index 7877dfdd..888520f8 100644 --- a/src/agentex/types/tool_request_delta.py +++ b/src/agentex/types/tool_request_delta.py @@ -9,6 +9,8 @@ class ToolRequestDelta(BaseModel): + """Delta for tool request updates""" + name: str tool_call_id: str diff --git a/src/agentex/types/tool_response_delta.py b/src/agentex/types/tool_response_delta.py index 383770db..8c34a16a 100644 --- a/src/agentex/types/tool_response_delta.py +++ b/src/agentex/types/tool_response_delta.py @@ -9,6 +9,8 @@ class ToolResponseDelta(BaseModel): + """Delta for tool response updates""" + name: str tool_call_id: str From 5b5cc054196b00fead90b1e305ca14dcaaca2378 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 8 Dec 2025 23:33:09 +0000 Subject: [PATCH 1051/1108] feat(api): add messages/paginated endpoint --- .stats.yml | 4 ++-- src/agentex/resources/messages/messages.py | 10 ++++++++-- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/.stats.yml b/.stats.yml index 783a2c01..c62711a9 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-8f9296ac9fa68bb264c4739463e55ce27cdafb31b705b27600d6656db7b0dac5.yml +openapi_spec_hash: 8df92140f49cace852d7b71b0964da5b config_hash: 0197f86ba1a4b1b5ce813d0e62138588 diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index 401acccb..e226c732 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -192,7 +192,10 @@ def list( timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ - List Messages + List messages for a task with offset-based pagination. + + For cursor-based pagination with infinite scroll support, use + /messages/paginated. Args: task_id: The task ID @@ -385,7 +388,10 @@ async def list( timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ - List Messages + List messages for a task with offset-based pagination. + + For cursor-based pagination with infinite scroll support, use + /messages/paginated. Args: task_id: The task ID From 5be645f677bb75166abbb08543cf2ac201af493a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 8 Dec 2025 23:33:51 +0000 Subject: [PATCH 1052/1108] feat(api): add messages/paginated to stainless config --- .stats.yml | 4 +- api.md | 2 + src/agentex/resources/messages/messages.py | 148 +++++++++++++++++- src/agentex/types/__init__.py | 2 + .../types/message_list_paginated_params.py | 19 +++ .../types/message_list_paginated_response.py | 21 +++ tests/api_resources/test_messages.py | 91 +++++++++++ 7 files changed, 284 insertions(+), 3 deletions(-) create mode 100644 src/agentex/types/message_list_paginated_params.py create mode 100644 src/agentex/types/message_list_paginated_response.py diff --git a/.stats.yml b/.stats.yml index c62711a9..41cb5ce4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 34 +configured_endpoints: 35 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-8f9296ac9fa68bb264c4739463e55ce27cdafb31b705b27600d6656db7b0dac5.yml openapi_spec_hash: 8df92140f49cace852d7b71b0964da5b -config_hash: 0197f86ba1a4b1b5ce813d0e62138588 +config_hash: 32eb65911c08ac84d117cecdf2759869 diff --git a/api.md b/api.md index 2b397d0c..7e8e6800 100644 --- a/api.md +++ b/api.md @@ -72,6 +72,7 @@ from agentex.types import ( ToolRequestContent, ToolResponseContent, MessageListResponse, + MessageListPaginatedResponse, ) ``` @@ -81,6 +82,7 @@ Methods: - client.messages.retrieve(message_id) -> TaskMessage - client.messages.update(message_id, \*\*params) -> TaskMessage - client.messages.list(\*\*params) -> MessageListResponse +- client.messages.list_paginated(\*\*params) -> MessageListPaginatedResponse ## Batch diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index e226c732..e1256449 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -15,7 +15,12 @@ BatchResourceWithStreamingResponse, AsyncBatchResourceWithStreamingResponse, ) -from ...types import message_list_params, message_create_params, message_update_params +from ...types import ( + message_list_params, + message_create_params, + message_update_params, + message_list_paginated_params, +) from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property @@ -30,6 +35,7 @@ from ...types.task_message import TaskMessage from ...types.message_list_response import MessageListResponse from ...types.task_message_content_param import TaskMessageContentParam +from ...types.message_list_paginated_response import MessageListPaginatedResponse __all__ = ["MessagesResource", "AsyncMessagesResource"] @@ -229,6 +235,70 @@ def list( cast_to=MessageListResponse, ) + def list_paginated( + self, + *, + task_id: str, + cursor: Optional[str] | Omit = omit, + direction: Literal["older", "newer"] | Omit = omit, + limit: int | 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, + ) -> MessageListPaginatedResponse: + """ + List messages for a task with cursor-based pagination. + + This endpoint is designed for infinite scroll UIs where new messages may arrive + while paginating through older ones. + + Args: task_id: The task ID to filter messages by limit: Maximum number of + messages to return (default: 50) cursor: Opaque cursor string for pagination. + Pass the `next_cursor` from a previous response to get the next page. direction: + Pagination direction - "older" to get older messages (default), "newer" to get + newer messages. + + Returns: PaginatedMessagesResponse with: - data: List of messages (newest first + when direction="older") - next_cursor: Cursor for fetching the next page (null + if no more pages) - has_more: Whether there are more messages to fetch + + Example: First request: GET /messages/paginated?task_id=xxx&limit=50 Next page: + GET /messages/paginated?task_id=xxx&limit=50&cursor= + + Args: + task_id: The task ID + + 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 + """ + return self._get( + "/messages/paginated", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "task_id": task_id, + "cursor": cursor, + "direction": direction, + "limit": limit, + }, + message_list_paginated_params.MessageListPaginatedParams, + ), + ), + cast_to=MessageListPaginatedResponse, + ) + class AsyncMessagesResource(AsyncAPIResource): @cached_property @@ -425,6 +495,70 @@ async def list( cast_to=MessageListResponse, ) + async def list_paginated( + self, + *, + task_id: str, + cursor: Optional[str] | Omit = omit, + direction: Literal["older", "newer"] | Omit = omit, + limit: int | 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, + ) -> MessageListPaginatedResponse: + """ + List messages for a task with cursor-based pagination. + + This endpoint is designed for infinite scroll UIs where new messages may arrive + while paginating through older ones. + + Args: task_id: The task ID to filter messages by limit: Maximum number of + messages to return (default: 50) cursor: Opaque cursor string for pagination. + Pass the `next_cursor` from a previous response to get the next page. direction: + Pagination direction - "older" to get older messages (default), "newer" to get + newer messages. + + Returns: PaginatedMessagesResponse with: - data: List of messages (newest first + when direction="older") - next_cursor: Cursor for fetching the next page (null + if no more pages) - has_more: Whether there are more messages to fetch + + Example: First request: GET /messages/paginated?task_id=xxx&limit=50 Next page: + GET /messages/paginated?task_id=xxx&limit=50&cursor= + + Args: + task_id: The task ID + + 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 + """ + return await self._get( + "/messages/paginated", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "task_id": task_id, + "cursor": cursor, + "direction": direction, + "limit": limit, + }, + message_list_paginated_params.MessageListPaginatedParams, + ), + ), + cast_to=MessageListPaginatedResponse, + ) + class MessagesResourceWithRawResponse: def __init__(self, messages: MessagesResource) -> None: @@ -442,6 +576,9 @@ def __init__(self, messages: MessagesResource) -> None: self.list = to_raw_response_wrapper( messages.list, ) + self.list_paginated = to_raw_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> BatchResourceWithRawResponse: @@ -464,6 +601,9 @@ def __init__(self, messages: AsyncMessagesResource) -> None: self.list = async_to_raw_response_wrapper( messages.list, ) + self.list_paginated = async_to_raw_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> AsyncBatchResourceWithRawResponse: @@ -486,6 +626,9 @@ def __init__(self, messages: MessagesResource) -> None: self.list = to_streamed_response_wrapper( messages.list, ) + self.list_paginated = to_streamed_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> BatchResourceWithStreamingResponse: @@ -508,6 +651,9 @@ def __init__(self, messages: AsyncMessagesResource) -> None: self.list = async_to_streamed_response_wrapper( messages.list, ) + self.list_paginated = async_to_streamed_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> AsyncBatchResourceWithStreamingResponse: diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 47e148bb..8628bd3c 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -62,4 +62,6 @@ from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam from .task_retrieve_by_name_params import TaskRetrieveByNameParams as TaskRetrieveByNameParams +from .message_list_paginated_params import MessageListPaginatedParams as MessageListPaginatedParams from .task_retrieve_by_name_response import TaskRetrieveByNameResponse as TaskRetrieveByNameResponse +from .message_list_paginated_response import MessageListPaginatedResponse as MessageListPaginatedResponse diff --git a/src/agentex/types/message_list_paginated_params.py b/src/agentex/types/message_list_paginated_params.py new file mode 100644 index 00000000..6dfe1e7e --- /dev/null +++ b/src/agentex/types/message_list_paginated_params.py @@ -0,0 +1,19 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Literal, Required, TypedDict + +__all__ = ["MessageListPaginatedParams"] + + +class MessageListPaginatedParams(TypedDict, total=False): + task_id: Required[str] + """The task ID""" + + cursor: Optional[str] + + direction: Literal["older", "newer"] + + limit: int diff --git a/src/agentex/types/message_list_paginated_response.py b/src/agentex/types/message_list_paginated_response.py new file mode 100644 index 00000000..40af0b4a --- /dev/null +++ b/src/agentex/types/message_list_paginated_response.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from .._models import BaseModel +from .task_message import TaskMessage + +__all__ = ["MessageListPaginatedResponse"] + + +class MessageListPaginatedResponse(BaseModel): + """Response with cursor pagination metadata.""" + + data: List[TaskMessage] + """List of messages""" + + has_more: Optional[bool] = None + """Whether there are more messages to fetch""" + + next_cursor: Optional[str] = None + """Cursor for fetching the next page of older messages""" diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py index ac2ccc16..4b234334 100644 --- a/tests/api_resources/test_messages.py +++ b/tests/api_resources/test_messages.py @@ -12,6 +12,7 @@ from agentex.types import ( TaskMessage, MessageListResponse, + MessageListPaginatedResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -272,6 +273,51 @@ def test_streaming_response_list(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_list_paginated(self, client: Agentex) -> None: + message = client.messages.list_paginated( + task_id="task_id", + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_list_paginated_with_all_params(self, client: Agentex) -> None: + message = client.messages.list_paginated( + task_id="task_id", + cursor="cursor", + direction="older", + limit=0, + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_raw_response_list_paginated(self, client: Agentex) -> None: + response = client.messages.with_raw_response.list_paginated( + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_streaming_response_list_paginated(self, client: Agentex) -> None: + with client.messages.with_streaming_response.list_paginated( + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + assert cast(Any, response.is_closed) is True + class TestAsyncMessages: parametrize = pytest.mark.parametrize( @@ -529,3 +575,48 @@ async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None assert_matches_type(MessageListResponse, message, path=["response"]) assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_list_paginated(self, async_client: AsyncAgentex) -> None: + message = await async_client.messages.list_paginated( + task_id="task_id", + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_list_paginated_with_all_params(self, async_client: AsyncAgentex) -> None: + message = await async_client.messages.list_paginated( + task_id="task_id", + cursor="cursor", + direction="older", + limit=0, + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_raw_response_list_paginated(self, async_client: AsyncAgentex) -> None: + response = await async_client.messages.with_raw_response.list_paginated( + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = await response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_streaming_response_list_paginated(self, async_client: AsyncAgentex) -> None: + async with async_client.messages.with_streaming_response.list_paginated( + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = await response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + assert cast(Any, response.is_closed) is True From 9d35333246ea4642ff4ef29aa64c90562e42f054 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 00:32:18 +0000 Subject: [PATCH 1053/1108] feat(api): api update --- .stats.yml | 6 +- api.md | 2 - src/agentex/resources/messages/messages.py | 158 +----------------- src/agentex/types/__init__.py | 2 - .../types/message_list_paginated_params.py | 19 --- .../types/message_list_paginated_response.py | 21 --- tests/api_resources/test_messages.py | 91 ---------- 7 files changed, 6 insertions(+), 293 deletions(-) delete mode 100644 src/agentex/types/message_list_paginated_params.py delete mode 100644 src/agentex/types/message_list_paginated_response.py diff --git a/.stats.yml b/.stats.yml index 41cb5ce4..8ff7dd44 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 35 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-8f9296ac9fa68bb264c4739463e55ce27cdafb31b705b27600d6656db7b0dac5.yml -openapi_spec_hash: 8df92140f49cace852d7b71b0964da5b +configured_endpoints: 34 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 32eb65911c08ac84d117cecdf2759869 diff --git a/api.md b/api.md index 7e8e6800..2b397d0c 100644 --- a/api.md +++ b/api.md @@ -72,7 +72,6 @@ from agentex.types import ( ToolRequestContent, ToolResponseContent, MessageListResponse, - MessageListPaginatedResponse, ) ``` @@ -82,7 +81,6 @@ Methods: - client.messages.retrieve(message_id) -> TaskMessage - client.messages.update(message_id, \*\*params) -> TaskMessage - client.messages.list(\*\*params) -> MessageListResponse -- client.messages.list_paginated(\*\*params) -> MessageListPaginatedResponse ## Batch diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index e1256449..401acccb 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -15,12 +15,7 @@ BatchResourceWithStreamingResponse, AsyncBatchResourceWithStreamingResponse, ) -from ...types import ( - message_list_params, - message_create_params, - message_update_params, - message_list_paginated_params, -) +from ...types import message_list_params, message_create_params, message_update_params from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property @@ -35,7 +30,6 @@ from ...types.task_message import TaskMessage from ...types.message_list_response import MessageListResponse from ...types.task_message_content_param import TaskMessageContentParam -from ...types.message_list_paginated_response import MessageListPaginatedResponse __all__ = ["MessagesResource", "AsyncMessagesResource"] @@ -198,10 +192,7 @@ def list( timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ - List messages for a task with offset-based pagination. - - For cursor-based pagination with infinite scroll support, use - /messages/paginated. + List Messages Args: task_id: The task ID @@ -235,70 +226,6 @@ def list( cast_to=MessageListResponse, ) - def list_paginated( - self, - *, - task_id: str, - cursor: Optional[str] | Omit = omit, - direction: Literal["older", "newer"] | Omit = omit, - limit: int | 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, - ) -> MessageListPaginatedResponse: - """ - List messages for a task with cursor-based pagination. - - This endpoint is designed for infinite scroll UIs where new messages may arrive - while paginating through older ones. - - Args: task_id: The task ID to filter messages by limit: Maximum number of - messages to return (default: 50) cursor: Opaque cursor string for pagination. - Pass the `next_cursor` from a previous response to get the next page. direction: - Pagination direction - "older" to get older messages (default), "newer" to get - newer messages. - - Returns: PaginatedMessagesResponse with: - data: List of messages (newest first - when direction="older") - next_cursor: Cursor for fetching the next page (null - if no more pages) - has_more: Whether there are more messages to fetch - - Example: First request: GET /messages/paginated?task_id=xxx&limit=50 Next page: - GET /messages/paginated?task_id=xxx&limit=50&cursor= - - Args: - task_id: The task ID - - 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 - """ - return self._get( - "/messages/paginated", - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - query=maybe_transform( - { - "task_id": task_id, - "cursor": cursor, - "direction": direction, - "limit": limit, - }, - message_list_paginated_params.MessageListPaginatedParams, - ), - ), - cast_to=MessageListPaginatedResponse, - ) - class AsyncMessagesResource(AsyncAPIResource): @cached_property @@ -458,10 +385,7 @@ async def list( timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ - List messages for a task with offset-based pagination. - - For cursor-based pagination with infinite scroll support, use - /messages/paginated. + List Messages Args: task_id: The task ID @@ -495,70 +419,6 @@ async def list( cast_to=MessageListResponse, ) - async def list_paginated( - self, - *, - task_id: str, - cursor: Optional[str] | Omit = omit, - direction: Literal["older", "newer"] | Omit = omit, - limit: int | 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, - ) -> MessageListPaginatedResponse: - """ - List messages for a task with cursor-based pagination. - - This endpoint is designed for infinite scroll UIs where new messages may arrive - while paginating through older ones. - - Args: task_id: The task ID to filter messages by limit: Maximum number of - messages to return (default: 50) cursor: Opaque cursor string for pagination. - Pass the `next_cursor` from a previous response to get the next page. direction: - Pagination direction - "older" to get older messages (default), "newer" to get - newer messages. - - Returns: PaginatedMessagesResponse with: - data: List of messages (newest first - when direction="older") - next_cursor: Cursor for fetching the next page (null - if no more pages) - has_more: Whether there are more messages to fetch - - Example: First request: GET /messages/paginated?task_id=xxx&limit=50 Next page: - GET /messages/paginated?task_id=xxx&limit=50&cursor= - - Args: - task_id: The task ID - - 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 - """ - return await self._get( - "/messages/paginated", - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - query=await async_maybe_transform( - { - "task_id": task_id, - "cursor": cursor, - "direction": direction, - "limit": limit, - }, - message_list_paginated_params.MessageListPaginatedParams, - ), - ), - cast_to=MessageListPaginatedResponse, - ) - class MessagesResourceWithRawResponse: def __init__(self, messages: MessagesResource) -> None: @@ -576,9 +436,6 @@ def __init__(self, messages: MessagesResource) -> None: self.list = to_raw_response_wrapper( messages.list, ) - self.list_paginated = to_raw_response_wrapper( - messages.list_paginated, - ) @cached_property def batch(self) -> BatchResourceWithRawResponse: @@ -601,9 +458,6 @@ def __init__(self, messages: AsyncMessagesResource) -> None: self.list = async_to_raw_response_wrapper( messages.list, ) - self.list_paginated = async_to_raw_response_wrapper( - messages.list_paginated, - ) @cached_property def batch(self) -> AsyncBatchResourceWithRawResponse: @@ -626,9 +480,6 @@ def __init__(self, messages: MessagesResource) -> None: self.list = to_streamed_response_wrapper( messages.list, ) - self.list_paginated = to_streamed_response_wrapper( - messages.list_paginated, - ) @cached_property def batch(self) -> BatchResourceWithStreamingResponse: @@ -651,9 +502,6 @@ def __init__(self, messages: AsyncMessagesResource) -> None: self.list = async_to_streamed_response_wrapper( messages.list, ) - self.list_paginated = async_to_streamed_response_wrapper( - messages.list_paginated, - ) @cached_property def batch(self) -> AsyncBatchResourceWithStreamingResponse: diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 8628bd3c..47e148bb 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -62,6 +62,4 @@ from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam from .task_retrieve_by_name_params import TaskRetrieveByNameParams as TaskRetrieveByNameParams -from .message_list_paginated_params import MessageListPaginatedParams as MessageListPaginatedParams from .task_retrieve_by_name_response import TaskRetrieveByNameResponse as TaskRetrieveByNameResponse -from .message_list_paginated_response import MessageListPaginatedResponse as MessageListPaginatedResponse diff --git a/src/agentex/types/message_list_paginated_params.py b/src/agentex/types/message_list_paginated_params.py deleted file mode 100644 index 6dfe1e7e..00000000 --- a/src/agentex/types/message_list_paginated_params.py +++ /dev/null @@ -1,19 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Optional -from typing_extensions import Literal, Required, TypedDict - -__all__ = ["MessageListPaginatedParams"] - - -class MessageListPaginatedParams(TypedDict, total=False): - task_id: Required[str] - """The task ID""" - - cursor: Optional[str] - - direction: Literal["older", "newer"] - - limit: int diff --git a/src/agentex/types/message_list_paginated_response.py b/src/agentex/types/message_list_paginated_response.py deleted file mode 100644 index 40af0b4a..00000000 --- a/src/agentex/types/message_list_paginated_response.py +++ /dev/null @@ -1,21 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import List, Optional - -from .._models import BaseModel -from .task_message import TaskMessage - -__all__ = ["MessageListPaginatedResponse"] - - -class MessageListPaginatedResponse(BaseModel): - """Response with cursor pagination metadata.""" - - data: List[TaskMessage] - """List of messages""" - - has_more: Optional[bool] = None - """Whether there are more messages to fetch""" - - next_cursor: Optional[str] = None - """Cursor for fetching the next page of older messages""" diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py index 4b234334..ac2ccc16 100644 --- a/tests/api_resources/test_messages.py +++ b/tests/api_resources/test_messages.py @@ -12,7 +12,6 @@ from agentex.types import ( TaskMessage, MessageListResponse, - MessageListPaginatedResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -273,51 +272,6 @@ def test_streaming_response_list(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_list_paginated(self, client: Agentex) -> None: - message = client.messages.list_paginated( - task_id="task_id", - ) - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_list_paginated_with_all_params(self, client: Agentex) -> None: - message = client.messages.list_paginated( - task_id="task_id", - cursor="cursor", - direction="older", - limit=0, - ) - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_raw_response_list_paginated(self, client: Agentex) -> None: - response = client.messages.with_raw_response.list_paginated( - task_id="task_id", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - message = response.parse() - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_streaming_response_list_paginated(self, client: Agentex) -> None: - with client.messages.with_streaming_response.list_paginated( - task_id="task_id", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - message = response.parse() - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - assert cast(Any, response.is_closed) is True - class TestAsyncMessages: parametrize = pytest.mark.parametrize( @@ -575,48 +529,3 @@ async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None assert_matches_type(MessageListResponse, message, path=["response"]) assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_list_paginated(self, async_client: AsyncAgentex) -> None: - message = await async_client.messages.list_paginated( - task_id="task_id", - ) - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_list_paginated_with_all_params(self, async_client: AsyncAgentex) -> None: - message = await async_client.messages.list_paginated( - task_id="task_id", - cursor="cursor", - direction="older", - limit=0, - ) - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_raw_response_list_paginated(self, async_client: AsyncAgentex) -> None: - response = await async_client.messages.with_raw_response.list_paginated( - task_id="task_id", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - message = await response.parse() - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_streaming_response_list_paginated(self, async_client: AsyncAgentex) -> None: - async with async_client.messages.with_streaming_response.list_paginated( - task_id="task_id", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - message = await response.parse() - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - assert cast(Any, response.is_closed) is True From 6a337118841a20b19e96cbc36f7b9891e0e0478c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 02:32:07 +0000 Subject: [PATCH 1054/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 8ff7dd44..86dd1f9c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 32eb65911c08ac84d117cecdf2759869 From f3367f2168dd8d100289b306fc18347f92ce9299 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 03:32:13 +0000 Subject: [PATCH 1055/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 86dd1f9c..8ff7dd44 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 32eb65911c08ac84d117cecdf2759869 From f922b8d34ee84a10860d70208b1a36e47e42158f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 04:31:54 +0000 Subject: [PATCH 1056/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 8ff7dd44..86dd1f9c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 32eb65911c08ac84d117cecdf2759869 From 8f5833a85a438caf61993c3da5715e230e48e57c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 05:31:52 +0000 Subject: [PATCH 1057/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 86dd1f9c..8ff7dd44 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 32eb65911c08ac84d117cecdf2759869 From 05077ffb4d24cf3d5046c6ce84b018a63e6559a7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 06:31:59 +0000 Subject: [PATCH 1058/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 8ff7dd44..86dd1f9c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 32eb65911c08ac84d117cecdf2759869 From 0933d98beb7a902a1314b6a0e27ff24d5cdacfea Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 09:32:03 +0000 Subject: [PATCH 1059/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 86dd1f9c..8ff7dd44 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 32eb65911c08ac84d117cecdf2759869 From 0d1032e484f298f3b87cd0ce3279735e4b7f09cb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 09:51:27 +0000 Subject: [PATCH 1060/1108] feat(api): manual updates --- .stats.yml | 6 +- api.md | 2 + src/agentex/resources/messages/messages.py | 158 +++++++++++++++++- src/agentex/types/__init__.py | 2 + .../types/message_list_paginated_params.py | 19 +++ .../types/message_list_paginated_response.py | 21 +++ tests/api_resources/test_messages.py | 91 ++++++++++ 7 files changed, 293 insertions(+), 6 deletions(-) create mode 100644 src/agentex/types/message_list_paginated_params.py create mode 100644 src/agentex/types/message_list_paginated_response.py diff --git a/.stats.yml b/.stats.yml index 8ff7dd44..41cb5ce4 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +configured_endpoints: 35 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-8f9296ac9fa68bb264c4739463e55ce27cdafb31b705b27600d6656db7b0dac5.yml +openapi_spec_hash: 8df92140f49cace852d7b71b0964da5b config_hash: 32eb65911c08ac84d117cecdf2759869 diff --git a/api.md b/api.md index 2b397d0c..7e8e6800 100644 --- a/api.md +++ b/api.md @@ -72,6 +72,7 @@ from agentex.types import ( ToolRequestContent, ToolResponseContent, MessageListResponse, + MessageListPaginatedResponse, ) ``` @@ -81,6 +82,7 @@ Methods: - client.messages.retrieve(message_id) -> TaskMessage - client.messages.update(message_id, \*\*params) -> TaskMessage - client.messages.list(\*\*params) -> MessageListResponse +- client.messages.list_paginated(\*\*params) -> MessageListPaginatedResponse ## Batch diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index 401acccb..e1256449 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -15,7 +15,12 @@ BatchResourceWithStreamingResponse, AsyncBatchResourceWithStreamingResponse, ) -from ...types import message_list_params, message_create_params, message_update_params +from ...types import ( + message_list_params, + message_create_params, + message_update_params, + message_list_paginated_params, +) from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property @@ -30,6 +35,7 @@ from ...types.task_message import TaskMessage from ...types.message_list_response import MessageListResponse from ...types.task_message_content_param import TaskMessageContentParam +from ...types.message_list_paginated_response import MessageListPaginatedResponse __all__ = ["MessagesResource", "AsyncMessagesResource"] @@ -192,7 +198,10 @@ def list( timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ - List Messages + List messages for a task with offset-based pagination. + + For cursor-based pagination with infinite scroll support, use + /messages/paginated. Args: task_id: The task ID @@ -226,6 +235,70 @@ def list( cast_to=MessageListResponse, ) + def list_paginated( + self, + *, + task_id: str, + cursor: Optional[str] | Omit = omit, + direction: Literal["older", "newer"] | Omit = omit, + limit: int | 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, + ) -> MessageListPaginatedResponse: + """ + List messages for a task with cursor-based pagination. + + This endpoint is designed for infinite scroll UIs where new messages may arrive + while paginating through older ones. + + Args: task_id: The task ID to filter messages by limit: Maximum number of + messages to return (default: 50) cursor: Opaque cursor string for pagination. + Pass the `next_cursor` from a previous response to get the next page. direction: + Pagination direction - "older" to get older messages (default), "newer" to get + newer messages. + + Returns: PaginatedMessagesResponse with: - data: List of messages (newest first + when direction="older") - next_cursor: Cursor for fetching the next page (null + if no more pages) - has_more: Whether there are more messages to fetch + + Example: First request: GET /messages/paginated?task_id=xxx&limit=50 Next page: + GET /messages/paginated?task_id=xxx&limit=50&cursor= + + Args: + task_id: The task ID + + 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 + """ + return self._get( + "/messages/paginated", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "task_id": task_id, + "cursor": cursor, + "direction": direction, + "limit": limit, + }, + message_list_paginated_params.MessageListPaginatedParams, + ), + ), + cast_to=MessageListPaginatedResponse, + ) + class AsyncMessagesResource(AsyncAPIResource): @cached_property @@ -385,7 +458,10 @@ async def list( timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ - List Messages + List messages for a task with offset-based pagination. + + For cursor-based pagination with infinite scroll support, use + /messages/paginated. Args: task_id: The task ID @@ -419,6 +495,70 @@ async def list( cast_to=MessageListResponse, ) + async def list_paginated( + self, + *, + task_id: str, + cursor: Optional[str] | Omit = omit, + direction: Literal["older", "newer"] | Omit = omit, + limit: int | 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, + ) -> MessageListPaginatedResponse: + """ + List messages for a task with cursor-based pagination. + + This endpoint is designed for infinite scroll UIs where new messages may arrive + while paginating through older ones. + + Args: task_id: The task ID to filter messages by limit: Maximum number of + messages to return (default: 50) cursor: Opaque cursor string for pagination. + Pass the `next_cursor` from a previous response to get the next page. direction: + Pagination direction - "older" to get older messages (default), "newer" to get + newer messages. + + Returns: PaginatedMessagesResponse with: - data: List of messages (newest first + when direction="older") - next_cursor: Cursor for fetching the next page (null + if no more pages) - has_more: Whether there are more messages to fetch + + Example: First request: GET /messages/paginated?task_id=xxx&limit=50 Next page: + GET /messages/paginated?task_id=xxx&limit=50&cursor= + + Args: + task_id: The task ID + + 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 + """ + return await self._get( + "/messages/paginated", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "task_id": task_id, + "cursor": cursor, + "direction": direction, + "limit": limit, + }, + message_list_paginated_params.MessageListPaginatedParams, + ), + ), + cast_to=MessageListPaginatedResponse, + ) + class MessagesResourceWithRawResponse: def __init__(self, messages: MessagesResource) -> None: @@ -436,6 +576,9 @@ def __init__(self, messages: MessagesResource) -> None: self.list = to_raw_response_wrapper( messages.list, ) + self.list_paginated = to_raw_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> BatchResourceWithRawResponse: @@ -458,6 +601,9 @@ def __init__(self, messages: AsyncMessagesResource) -> None: self.list = async_to_raw_response_wrapper( messages.list, ) + self.list_paginated = async_to_raw_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> AsyncBatchResourceWithRawResponse: @@ -480,6 +626,9 @@ def __init__(self, messages: MessagesResource) -> None: self.list = to_streamed_response_wrapper( messages.list, ) + self.list_paginated = to_streamed_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> BatchResourceWithStreamingResponse: @@ -502,6 +651,9 @@ def __init__(self, messages: AsyncMessagesResource) -> None: self.list = async_to_streamed_response_wrapper( messages.list, ) + self.list_paginated = async_to_streamed_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> AsyncBatchResourceWithStreamingResponse: diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 47e148bb..8628bd3c 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -62,4 +62,6 @@ from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam from .task_retrieve_by_name_params import TaskRetrieveByNameParams as TaskRetrieveByNameParams +from .message_list_paginated_params import MessageListPaginatedParams as MessageListPaginatedParams from .task_retrieve_by_name_response import TaskRetrieveByNameResponse as TaskRetrieveByNameResponse +from .message_list_paginated_response import MessageListPaginatedResponse as MessageListPaginatedResponse diff --git a/src/agentex/types/message_list_paginated_params.py b/src/agentex/types/message_list_paginated_params.py new file mode 100644 index 00000000..6dfe1e7e --- /dev/null +++ b/src/agentex/types/message_list_paginated_params.py @@ -0,0 +1,19 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Literal, Required, TypedDict + +__all__ = ["MessageListPaginatedParams"] + + +class MessageListPaginatedParams(TypedDict, total=False): + task_id: Required[str] + """The task ID""" + + cursor: Optional[str] + + direction: Literal["older", "newer"] + + limit: int diff --git a/src/agentex/types/message_list_paginated_response.py b/src/agentex/types/message_list_paginated_response.py new file mode 100644 index 00000000..40af0b4a --- /dev/null +++ b/src/agentex/types/message_list_paginated_response.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from .._models import BaseModel +from .task_message import TaskMessage + +__all__ = ["MessageListPaginatedResponse"] + + +class MessageListPaginatedResponse(BaseModel): + """Response with cursor pagination metadata.""" + + data: List[TaskMessage] + """List of messages""" + + has_more: Optional[bool] = None + """Whether there are more messages to fetch""" + + next_cursor: Optional[str] = None + """Cursor for fetching the next page of older messages""" diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py index ac2ccc16..4b234334 100644 --- a/tests/api_resources/test_messages.py +++ b/tests/api_resources/test_messages.py @@ -12,6 +12,7 @@ from agentex.types import ( TaskMessage, MessageListResponse, + MessageListPaginatedResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -272,6 +273,51 @@ def test_streaming_response_list(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_list_paginated(self, client: Agentex) -> None: + message = client.messages.list_paginated( + task_id="task_id", + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_list_paginated_with_all_params(self, client: Agentex) -> None: + message = client.messages.list_paginated( + task_id="task_id", + cursor="cursor", + direction="older", + limit=0, + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_raw_response_list_paginated(self, client: Agentex) -> None: + response = client.messages.with_raw_response.list_paginated( + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_streaming_response_list_paginated(self, client: Agentex) -> None: + with client.messages.with_streaming_response.list_paginated( + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + assert cast(Any, response.is_closed) is True + class TestAsyncMessages: parametrize = pytest.mark.parametrize( @@ -529,3 +575,48 @@ async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None assert_matches_type(MessageListResponse, message, path=["response"]) assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_list_paginated(self, async_client: AsyncAgentex) -> None: + message = await async_client.messages.list_paginated( + task_id="task_id", + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_list_paginated_with_all_params(self, async_client: AsyncAgentex) -> None: + message = await async_client.messages.list_paginated( + task_id="task_id", + cursor="cursor", + direction="older", + limit=0, + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_raw_response_list_paginated(self, async_client: AsyncAgentex) -> None: + response = await async_client.messages.with_raw_response.list_paginated( + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = await response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_streaming_response_list_paginated(self, async_client: AsyncAgentex) -> None: + async with async_client.messages.with_streaming_response.list_paginated( + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = await response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + assert cast(Any, response.is_closed) is True From fcb50bedbc3b49905ca7864642479b30a12ff837 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 10:31:51 +0000 Subject: [PATCH 1061/1108] feat(api): api update --- .stats.yml | 6 +- api.md | 2 - src/agentex/resources/messages/messages.py | 158 +----------------- src/agentex/types/__init__.py | 2 - .../types/message_list_paginated_params.py | 19 --- .../types/message_list_paginated_response.py | 21 --- tests/api_resources/test_messages.py | 91 ---------- 7 files changed, 6 insertions(+), 293 deletions(-) delete mode 100644 src/agentex/types/message_list_paginated_params.py delete mode 100644 src/agentex/types/message_list_paginated_response.py diff --git a/.stats.yml b/.stats.yml index 41cb5ce4..86dd1f9c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 35 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-8f9296ac9fa68bb264c4739463e55ce27cdafb31b705b27600d6656db7b0dac5.yml -openapi_spec_hash: 8df92140f49cace852d7b71b0964da5b +configured_endpoints: 34 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 32eb65911c08ac84d117cecdf2759869 diff --git a/api.md b/api.md index 7e8e6800..2b397d0c 100644 --- a/api.md +++ b/api.md @@ -72,7 +72,6 @@ from agentex.types import ( ToolRequestContent, ToolResponseContent, MessageListResponse, - MessageListPaginatedResponse, ) ``` @@ -82,7 +81,6 @@ Methods: - client.messages.retrieve(message_id) -> TaskMessage - client.messages.update(message_id, \*\*params) -> TaskMessage - client.messages.list(\*\*params) -> MessageListResponse -- client.messages.list_paginated(\*\*params) -> MessageListPaginatedResponse ## Batch diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index e1256449..401acccb 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -15,12 +15,7 @@ BatchResourceWithStreamingResponse, AsyncBatchResourceWithStreamingResponse, ) -from ...types import ( - message_list_params, - message_create_params, - message_update_params, - message_list_paginated_params, -) +from ...types import message_list_params, message_create_params, message_update_params from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property @@ -35,7 +30,6 @@ from ...types.task_message import TaskMessage from ...types.message_list_response import MessageListResponse from ...types.task_message_content_param import TaskMessageContentParam -from ...types.message_list_paginated_response import MessageListPaginatedResponse __all__ = ["MessagesResource", "AsyncMessagesResource"] @@ -198,10 +192,7 @@ def list( timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ - List messages for a task with offset-based pagination. - - For cursor-based pagination with infinite scroll support, use - /messages/paginated. + List Messages Args: task_id: The task ID @@ -235,70 +226,6 @@ def list( cast_to=MessageListResponse, ) - def list_paginated( - self, - *, - task_id: str, - cursor: Optional[str] | Omit = omit, - direction: Literal["older", "newer"] | Omit = omit, - limit: int | 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, - ) -> MessageListPaginatedResponse: - """ - List messages for a task with cursor-based pagination. - - This endpoint is designed for infinite scroll UIs where new messages may arrive - while paginating through older ones. - - Args: task_id: The task ID to filter messages by limit: Maximum number of - messages to return (default: 50) cursor: Opaque cursor string for pagination. - Pass the `next_cursor` from a previous response to get the next page. direction: - Pagination direction - "older" to get older messages (default), "newer" to get - newer messages. - - Returns: PaginatedMessagesResponse with: - data: List of messages (newest first - when direction="older") - next_cursor: Cursor for fetching the next page (null - if no more pages) - has_more: Whether there are more messages to fetch - - Example: First request: GET /messages/paginated?task_id=xxx&limit=50 Next page: - GET /messages/paginated?task_id=xxx&limit=50&cursor= - - Args: - task_id: The task ID - - 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 - """ - return self._get( - "/messages/paginated", - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - query=maybe_transform( - { - "task_id": task_id, - "cursor": cursor, - "direction": direction, - "limit": limit, - }, - message_list_paginated_params.MessageListPaginatedParams, - ), - ), - cast_to=MessageListPaginatedResponse, - ) - class AsyncMessagesResource(AsyncAPIResource): @cached_property @@ -458,10 +385,7 @@ async def list( timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ - List messages for a task with offset-based pagination. - - For cursor-based pagination with infinite scroll support, use - /messages/paginated. + List Messages Args: task_id: The task ID @@ -495,70 +419,6 @@ async def list( cast_to=MessageListResponse, ) - async def list_paginated( - self, - *, - task_id: str, - cursor: Optional[str] | Omit = omit, - direction: Literal["older", "newer"] | Omit = omit, - limit: int | 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, - ) -> MessageListPaginatedResponse: - """ - List messages for a task with cursor-based pagination. - - This endpoint is designed for infinite scroll UIs where new messages may arrive - while paginating through older ones. - - Args: task_id: The task ID to filter messages by limit: Maximum number of - messages to return (default: 50) cursor: Opaque cursor string for pagination. - Pass the `next_cursor` from a previous response to get the next page. direction: - Pagination direction - "older" to get older messages (default), "newer" to get - newer messages. - - Returns: PaginatedMessagesResponse with: - data: List of messages (newest first - when direction="older") - next_cursor: Cursor for fetching the next page (null - if no more pages) - has_more: Whether there are more messages to fetch - - Example: First request: GET /messages/paginated?task_id=xxx&limit=50 Next page: - GET /messages/paginated?task_id=xxx&limit=50&cursor= - - Args: - task_id: The task ID - - 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 - """ - return await self._get( - "/messages/paginated", - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - query=await async_maybe_transform( - { - "task_id": task_id, - "cursor": cursor, - "direction": direction, - "limit": limit, - }, - message_list_paginated_params.MessageListPaginatedParams, - ), - ), - cast_to=MessageListPaginatedResponse, - ) - class MessagesResourceWithRawResponse: def __init__(self, messages: MessagesResource) -> None: @@ -576,9 +436,6 @@ def __init__(self, messages: MessagesResource) -> None: self.list = to_raw_response_wrapper( messages.list, ) - self.list_paginated = to_raw_response_wrapper( - messages.list_paginated, - ) @cached_property def batch(self) -> BatchResourceWithRawResponse: @@ -601,9 +458,6 @@ def __init__(self, messages: AsyncMessagesResource) -> None: self.list = async_to_raw_response_wrapper( messages.list, ) - self.list_paginated = async_to_raw_response_wrapper( - messages.list_paginated, - ) @cached_property def batch(self) -> AsyncBatchResourceWithRawResponse: @@ -626,9 +480,6 @@ def __init__(self, messages: MessagesResource) -> None: self.list = to_streamed_response_wrapper( messages.list, ) - self.list_paginated = to_streamed_response_wrapper( - messages.list_paginated, - ) @cached_property def batch(self) -> BatchResourceWithStreamingResponse: @@ -651,9 +502,6 @@ def __init__(self, messages: AsyncMessagesResource) -> None: self.list = async_to_streamed_response_wrapper( messages.list, ) - self.list_paginated = async_to_streamed_response_wrapper( - messages.list_paginated, - ) @cached_property def batch(self) -> AsyncBatchResourceWithStreamingResponse: diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 8628bd3c..47e148bb 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -62,6 +62,4 @@ from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam from .task_retrieve_by_name_params import TaskRetrieveByNameParams as TaskRetrieveByNameParams -from .message_list_paginated_params import MessageListPaginatedParams as MessageListPaginatedParams from .task_retrieve_by_name_response import TaskRetrieveByNameResponse as TaskRetrieveByNameResponse -from .message_list_paginated_response import MessageListPaginatedResponse as MessageListPaginatedResponse diff --git a/src/agentex/types/message_list_paginated_params.py b/src/agentex/types/message_list_paginated_params.py deleted file mode 100644 index 6dfe1e7e..00000000 --- a/src/agentex/types/message_list_paginated_params.py +++ /dev/null @@ -1,19 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Optional -from typing_extensions import Literal, Required, TypedDict - -__all__ = ["MessageListPaginatedParams"] - - -class MessageListPaginatedParams(TypedDict, total=False): - task_id: Required[str] - """The task ID""" - - cursor: Optional[str] - - direction: Literal["older", "newer"] - - limit: int diff --git a/src/agentex/types/message_list_paginated_response.py b/src/agentex/types/message_list_paginated_response.py deleted file mode 100644 index 40af0b4a..00000000 --- a/src/agentex/types/message_list_paginated_response.py +++ /dev/null @@ -1,21 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import List, Optional - -from .._models import BaseModel -from .task_message import TaskMessage - -__all__ = ["MessageListPaginatedResponse"] - - -class MessageListPaginatedResponse(BaseModel): - """Response with cursor pagination metadata.""" - - data: List[TaskMessage] - """List of messages""" - - has_more: Optional[bool] = None - """Whether there are more messages to fetch""" - - next_cursor: Optional[str] = None - """Cursor for fetching the next page of older messages""" diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py index 4b234334..ac2ccc16 100644 --- a/tests/api_resources/test_messages.py +++ b/tests/api_resources/test_messages.py @@ -12,7 +12,6 @@ from agentex.types import ( TaskMessage, MessageListResponse, - MessageListPaginatedResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -273,51 +272,6 @@ def test_streaming_response_list(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_list_paginated(self, client: Agentex) -> None: - message = client.messages.list_paginated( - task_id="task_id", - ) - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_list_paginated_with_all_params(self, client: Agentex) -> None: - message = client.messages.list_paginated( - task_id="task_id", - cursor="cursor", - direction="older", - limit=0, - ) - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_raw_response_list_paginated(self, client: Agentex) -> None: - response = client.messages.with_raw_response.list_paginated( - task_id="task_id", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - message = response.parse() - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_streaming_response_list_paginated(self, client: Agentex) -> None: - with client.messages.with_streaming_response.list_paginated( - task_id="task_id", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - message = response.parse() - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - assert cast(Any, response.is_closed) is True - class TestAsyncMessages: parametrize = pytest.mark.parametrize( @@ -575,48 +529,3 @@ async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None assert_matches_type(MessageListResponse, message, path=["response"]) assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_list_paginated(self, async_client: AsyncAgentex) -> None: - message = await async_client.messages.list_paginated( - task_id="task_id", - ) - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_list_paginated_with_all_params(self, async_client: AsyncAgentex) -> None: - message = await async_client.messages.list_paginated( - task_id="task_id", - cursor="cursor", - direction="older", - limit=0, - ) - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_raw_response_list_paginated(self, async_client: AsyncAgentex) -> None: - response = await async_client.messages.with_raw_response.list_paginated( - task_id="task_id", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - message = await response.parse() - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_streaming_response_list_paginated(self, async_client: AsyncAgentex) -> None: - async with async_client.messages.with_streaming_response.list_paginated( - task_id="task_id", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - message = await response.parse() - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - assert cast(Any, response.is_closed) is True From d7afe57e889f9bd0f59d6b6fb88c327a4e3edab3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 12:31:51 +0000 Subject: [PATCH 1062/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 86dd1f9c..8ff7dd44 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 32eb65911c08ac84d117cecdf2759869 From 63fe42b2e8d90702c16aaecbf0c3d3468907dee7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 13:32:01 +0000 Subject: [PATCH 1063/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 8ff7dd44..86dd1f9c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 32eb65911c08ac84d117cecdf2759869 From c8447e87dea067c8e976295e96fb41c466e1cbee Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 14:32:09 +0000 Subject: [PATCH 1064/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 86dd1f9c..8ff7dd44 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 32eb65911c08ac84d117cecdf2759869 From 3b984aa91ed874d50933b360811d7cc229dd3fa3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 15:32:09 +0000 Subject: [PATCH 1065/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 8ff7dd44..86dd1f9c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 32eb65911c08ac84d117cecdf2759869 From 9b5e4aeebf478c3d2213186ca02fb8b673705d9c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 17:32:26 +0000 Subject: [PATCH 1066/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 86dd1f9c..8ff7dd44 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 32eb65911c08ac84d117cecdf2759869 From 9ab29f5ce100b5548e513f9f705fdd7e46bbbf9b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 17:46:57 +0000 Subject: [PATCH 1067/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index a25d414b..1b77f506 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.6.7" + ".": "0.7.0" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 16017ae3..39b4d483 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.6.7" +version = "0.7.0" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index f5647ae4..24f2919e 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.6.7" # x-release-please-version +__version__ = "0.7.0" # x-release-please-version From beb257081435586312d5bbc1ded684d3723aa7e0 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 19:32:12 +0000 Subject: [PATCH 1068/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 8ff7dd44..86dd1f9c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml +openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 config_hash: 32eb65911c08ac84d117cecdf2759869 From 5570d0008fcf12e5ad8e766841ec13c000eb0285 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 20:14:30 +0000 Subject: [PATCH 1069/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 86dd1f9c..8ff7dd44 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-33aeed53e882a3bea6a93f73f1ff365860e3363f5994f8d6923e3a955d51110f.yml -openapi_spec_hash: 20f924c68bf7ef0b532930d9de79c9e0 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml +openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 config_hash: 32eb65911c08ac84d117cecdf2759869 From f5482dd471068c818c02517fb720f97a292fdd08 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 20:25:19 +0000 Subject: [PATCH 1070/1108] feat(api): api update --- .stats.yml | 6 +- api.md | 2 + src/agentex/resources/messages/messages.py | 158 +++++++++++++++++- src/agentex/types/__init__.py | 2 + .../types/message_list_paginated_params.py | 19 +++ .../types/message_list_paginated_response.py | 21 +++ tests/api_resources/test_messages.py | 91 ++++++++++ 7 files changed, 293 insertions(+), 6 deletions(-) create mode 100644 src/agentex/types/message_list_paginated_params.py create mode 100644 src/agentex/types/message_list_paginated_response.py diff --git a/.stats.yml b/.stats.yml index 8ff7dd44..3b293f90 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-00b021144c274cce2211ea6c6f90b60b6f88f33a7286a6bf38f4f803ae4c1643.yml -openapi_spec_hash: d48de43356b6d0edc3f7a44b5980f7a0 +configured_endpoints: 35 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6feb0601dafb255298a2f1da01d64541d40da90aeb527e2f444c49c993e8c162.yml +openapi_spec_hash: 973cd2ed3c945818d15b7deee0b25d71 config_hash: 32eb65911c08ac84d117cecdf2759869 diff --git a/api.md b/api.md index 2b397d0c..7e8e6800 100644 --- a/api.md +++ b/api.md @@ -72,6 +72,7 @@ from agentex.types import ( ToolRequestContent, ToolResponseContent, MessageListResponse, + MessageListPaginatedResponse, ) ``` @@ -81,6 +82,7 @@ Methods: - client.messages.retrieve(message_id) -> TaskMessage - client.messages.update(message_id, \*\*params) -> TaskMessage - client.messages.list(\*\*params) -> MessageListResponse +- client.messages.list_paginated(\*\*params) -> MessageListPaginatedResponse ## Batch diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index 401acccb..e1256449 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -15,7 +15,12 @@ BatchResourceWithStreamingResponse, AsyncBatchResourceWithStreamingResponse, ) -from ...types import message_list_params, message_create_params, message_update_params +from ...types import ( + message_list_params, + message_create_params, + message_update_params, + message_list_paginated_params, +) from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property @@ -30,6 +35,7 @@ from ...types.task_message import TaskMessage from ...types.message_list_response import MessageListResponse from ...types.task_message_content_param import TaskMessageContentParam +from ...types.message_list_paginated_response import MessageListPaginatedResponse __all__ = ["MessagesResource", "AsyncMessagesResource"] @@ -192,7 +198,10 @@ def list( timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ - List Messages + List messages for a task with offset-based pagination. + + For cursor-based pagination with infinite scroll support, use + /messages/paginated. Args: task_id: The task ID @@ -226,6 +235,70 @@ def list( cast_to=MessageListResponse, ) + def list_paginated( + self, + *, + task_id: str, + cursor: Optional[str] | Omit = omit, + direction: Literal["older", "newer"] | Omit = omit, + limit: int | 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, + ) -> MessageListPaginatedResponse: + """ + List messages for a task with cursor-based pagination. + + This endpoint is designed for infinite scroll UIs where new messages may arrive + while paginating through older ones. + + Args: task_id: The task ID to filter messages by limit: Maximum number of + messages to return (default: 50) cursor: Opaque cursor string for pagination. + Pass the `next_cursor` from a previous response to get the next page. direction: + Pagination direction - "older" to get older messages (default), "newer" to get + newer messages. + + Returns: PaginatedMessagesResponse with: - data: List of messages (newest first + when direction="older") - next_cursor: Cursor for fetching the next page (null + if no more pages) - has_more: Whether there are more messages to fetch + + Example: First request: GET /messages/paginated?task_id=xxx&limit=50 Next page: + GET /messages/paginated?task_id=xxx&limit=50&cursor= + + Args: + task_id: The task ID + + 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 + """ + return self._get( + "/messages/paginated", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "task_id": task_id, + "cursor": cursor, + "direction": direction, + "limit": limit, + }, + message_list_paginated_params.MessageListPaginatedParams, + ), + ), + cast_to=MessageListPaginatedResponse, + ) + class AsyncMessagesResource(AsyncAPIResource): @cached_property @@ -385,7 +458,10 @@ async def list( timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ - List Messages + List messages for a task with offset-based pagination. + + For cursor-based pagination with infinite scroll support, use + /messages/paginated. Args: task_id: The task ID @@ -419,6 +495,70 @@ async def list( cast_to=MessageListResponse, ) + async def list_paginated( + self, + *, + task_id: str, + cursor: Optional[str] | Omit = omit, + direction: Literal["older", "newer"] | Omit = omit, + limit: int | 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, + ) -> MessageListPaginatedResponse: + """ + List messages for a task with cursor-based pagination. + + This endpoint is designed for infinite scroll UIs where new messages may arrive + while paginating through older ones. + + Args: task_id: The task ID to filter messages by limit: Maximum number of + messages to return (default: 50) cursor: Opaque cursor string for pagination. + Pass the `next_cursor` from a previous response to get the next page. direction: + Pagination direction - "older" to get older messages (default), "newer" to get + newer messages. + + Returns: PaginatedMessagesResponse with: - data: List of messages (newest first + when direction="older") - next_cursor: Cursor for fetching the next page (null + if no more pages) - has_more: Whether there are more messages to fetch + + Example: First request: GET /messages/paginated?task_id=xxx&limit=50 Next page: + GET /messages/paginated?task_id=xxx&limit=50&cursor= + + Args: + task_id: The task ID + + 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 + """ + return await self._get( + "/messages/paginated", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "task_id": task_id, + "cursor": cursor, + "direction": direction, + "limit": limit, + }, + message_list_paginated_params.MessageListPaginatedParams, + ), + ), + cast_to=MessageListPaginatedResponse, + ) + class MessagesResourceWithRawResponse: def __init__(self, messages: MessagesResource) -> None: @@ -436,6 +576,9 @@ def __init__(self, messages: MessagesResource) -> None: self.list = to_raw_response_wrapper( messages.list, ) + self.list_paginated = to_raw_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> BatchResourceWithRawResponse: @@ -458,6 +601,9 @@ def __init__(self, messages: AsyncMessagesResource) -> None: self.list = async_to_raw_response_wrapper( messages.list, ) + self.list_paginated = async_to_raw_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> AsyncBatchResourceWithRawResponse: @@ -480,6 +626,9 @@ def __init__(self, messages: MessagesResource) -> None: self.list = to_streamed_response_wrapper( messages.list, ) + self.list_paginated = to_streamed_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> BatchResourceWithStreamingResponse: @@ -502,6 +651,9 @@ def __init__(self, messages: AsyncMessagesResource) -> None: self.list = async_to_streamed_response_wrapper( messages.list, ) + self.list_paginated = async_to_streamed_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> AsyncBatchResourceWithStreamingResponse: diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 47e148bb..8628bd3c 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -62,4 +62,6 @@ from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam from .task_retrieve_by_name_params import TaskRetrieveByNameParams as TaskRetrieveByNameParams +from .message_list_paginated_params import MessageListPaginatedParams as MessageListPaginatedParams from .task_retrieve_by_name_response import TaskRetrieveByNameResponse as TaskRetrieveByNameResponse +from .message_list_paginated_response import MessageListPaginatedResponse as MessageListPaginatedResponse diff --git a/src/agentex/types/message_list_paginated_params.py b/src/agentex/types/message_list_paginated_params.py new file mode 100644 index 00000000..6dfe1e7e --- /dev/null +++ b/src/agentex/types/message_list_paginated_params.py @@ -0,0 +1,19 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Literal, Required, TypedDict + +__all__ = ["MessageListPaginatedParams"] + + +class MessageListPaginatedParams(TypedDict, total=False): + task_id: Required[str] + """The task ID""" + + cursor: Optional[str] + + direction: Literal["older", "newer"] + + limit: int diff --git a/src/agentex/types/message_list_paginated_response.py b/src/agentex/types/message_list_paginated_response.py new file mode 100644 index 00000000..40af0b4a --- /dev/null +++ b/src/agentex/types/message_list_paginated_response.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from .._models import BaseModel +from .task_message import TaskMessage + +__all__ = ["MessageListPaginatedResponse"] + + +class MessageListPaginatedResponse(BaseModel): + """Response with cursor pagination metadata.""" + + data: List[TaskMessage] + """List of messages""" + + has_more: Optional[bool] = None + """Whether there are more messages to fetch""" + + next_cursor: Optional[str] = None + """Cursor for fetching the next page of older messages""" diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py index ac2ccc16..4b234334 100644 --- a/tests/api_resources/test_messages.py +++ b/tests/api_resources/test_messages.py @@ -12,6 +12,7 @@ from agentex.types import ( TaskMessage, MessageListResponse, + MessageListPaginatedResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -272,6 +273,51 @@ def test_streaming_response_list(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_list_paginated(self, client: Agentex) -> None: + message = client.messages.list_paginated( + task_id="task_id", + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_list_paginated_with_all_params(self, client: Agentex) -> None: + message = client.messages.list_paginated( + task_id="task_id", + cursor="cursor", + direction="older", + limit=0, + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_raw_response_list_paginated(self, client: Agentex) -> None: + response = client.messages.with_raw_response.list_paginated( + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_streaming_response_list_paginated(self, client: Agentex) -> None: + with client.messages.with_streaming_response.list_paginated( + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + assert cast(Any, response.is_closed) is True + class TestAsyncMessages: parametrize = pytest.mark.parametrize( @@ -529,3 +575,48 @@ async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None assert_matches_type(MessageListResponse, message, path=["response"]) assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_list_paginated(self, async_client: AsyncAgentex) -> None: + message = await async_client.messages.list_paginated( + task_id="task_id", + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_list_paginated_with_all_params(self, async_client: AsyncAgentex) -> None: + message = await async_client.messages.list_paginated( + task_id="task_id", + cursor="cursor", + direction="older", + limit=0, + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_raw_response_list_paginated(self, async_client: AsyncAgentex) -> None: + response = await async_client.messages.with_raw_response.list_paginated( + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = await response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_streaming_response_list_paginated(self, async_client: AsyncAgentex) -> None: + async with async_client.messages.with_streaming_response.list_paginated( + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = await response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + assert cast(Any, response.is_closed) is True From ba8d43c671355af6391c4736b99323769de90161 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 9 Dec 2025 20:54:22 +0000 Subject: [PATCH 1071/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 1b77f506..1bc57136 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.7.0" + ".": "0.7.1" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 39b4d483..77978e42 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.7.0" +version = "0.7.1" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 24f2919e..37c1d677 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.7.0" # x-release-please-version +__version__ = "0.7.1" # x-release-please-version From e46198019a66f07a6a8b9eb39f5bbe134c2095c6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 10 Dec 2025 18:56:30 +0000 Subject: [PATCH 1072/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 1bc57136..7412044d 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.7.1" + ".": "0.7.2" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 77978e42..37f6d69e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.7.1" +version = "0.7.2" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 37c1d677..6b0a87fb 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.7.1" # x-release-please-version +__version__ = "0.7.2" # x-release-please-version From a8b796792cce0796c671b82831024a84426cc2c6 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 10 Dec 2025 19:16:18 +0000 Subject: [PATCH 1073/1108] chore(internal): version bump --- .release-please-manifest.json | 2 +- pyproject.toml | 2 +- src/agentex/_version.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 7412044d..88ca3ece 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.7.2" + ".": "0.7.3" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 37f6d69e..529f6faf 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "agentex-sdk" -version = "0.7.2" +version = "0.7.3" description = "The official Python library for the agentex API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/agentex/_version.py b/src/agentex/_version.py index 6b0a87fb..85b95807 100644 --- a/src/agentex/_version.py +++ b/src/agentex/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "agentex" -__version__ = "0.7.2" # x-release-please-version +__version__ = "0.7.3" # x-release-please-version From d84c749c76837fbf49447fd2cc517450962d1a2e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 12 Dec 2025 19:31:57 +0000 Subject: [PATCH 1074/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 3b293f90..fbcaba61 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 35 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-6feb0601dafb255298a2f1da01d64541d40da90aeb527e2f444c49c993e8c162.yml -openapi_spec_hash: 973cd2ed3c945818d15b7deee0b25d71 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-8f9296ac9fa68bb264c4739463e55ce27cdafb31b705b27600d6656db7b0dac5.yml +openapi_spec_hash: 47f4675ac3c7198869240b5c6f33f8fd config_hash: 32eb65911c08ac84d117cecdf2759869 From 43f30c539bebd73d2f9bead35df5c1416211f898 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Dec 2025 02:31:56 +0000 Subject: [PATCH 1075/1108] feat(api): api update --- .stats.yml | 6 +- api.md | 8 +- src/agentex/resources/agents.py | 46 +---- src/agentex/resources/messages/messages.py | 174 +----------------- src/agentex/resources/spans.py | 30 +-- src/agentex/resources/states.py | 32 ---- src/agentex/resources/tasks.py | 78 ++------ src/agentex/resources/tracker.py | 32 ---- src/agentex/types/__init__.py | 6 - src/agentex/types/acp_type.py | 2 +- src/agentex/types/agent.py | 7 +- src/agentex/types/agent_list_params.py | 12 -- .../types/message_list_paginated_params.py | 19 -- .../types/message_list_paginated_response.py | 21 --- src/agentex/types/message_list_params.py | 8 +- src/agentex/types/span_list_params.py | 8 - src/agentex/types/state_list_params.py | 12 -- src/agentex/types/task_list_params.py | 14 +- src/agentex/types/task_list_response.py | 35 +--- .../types/task_retrieve_by_name_params.py | 12 -- .../types/task_retrieve_by_name_response.py | 32 ---- src/agentex/types/task_retrieve_params.py | 12 -- src/agentex/types/task_retrieve_response.py | 32 ---- src/agentex/types/tracker_list_params.py | 12 -- tests/api_resources/test_agents.py | 8 - tests/api_resources/test_messages.py | 97 ---------- tests/api_resources/test_spans.py | 8 - tests/api_resources/test_states.py | 8 - tests/api_resources/test_tasks.py | 108 +++-------- tests/api_resources/test_tracker.py | 8 - 30 files changed, 70 insertions(+), 817 deletions(-) delete mode 100644 src/agentex/types/message_list_paginated_params.py delete mode 100644 src/agentex/types/message_list_paginated_response.py delete mode 100644 src/agentex/types/task_retrieve_by_name_params.py delete mode 100644 src/agentex/types/task_retrieve_by_name_response.py delete mode 100644 src/agentex/types/task_retrieve_params.py delete mode 100644 src/agentex/types/task_retrieve_response.py diff --git a/.stats.yml b/.stats.yml index fbcaba61..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 35 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-8f9296ac9fa68bb264c4739463e55ce27cdafb31b705b27600d6656db7b0dac5.yml -openapi_spec_hash: 47f4675ac3c7198869240b5c6f33f8fd +configured_endpoints: 34 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 diff --git a/api.md b/api.md index 7e8e6800..4e3e6f83 100644 --- a/api.md +++ b/api.md @@ -43,16 +43,16 @@ Methods: Types: ```python -from agentex.types import Task, TaskRetrieveResponse, TaskListResponse, TaskRetrieveByNameResponse +from agentex.types import Task, TaskListResponse ``` Methods: -- client.tasks.retrieve(task_id, \*\*params) -> TaskRetrieveResponse +- client.tasks.retrieve(task_id) -> Task - client.tasks.list(\*\*params) -> TaskListResponse - client.tasks.delete(task_id) -> DeleteResponse - client.tasks.delete_by_name(task_name) -> DeleteResponse -- client.tasks.retrieve_by_name(task_name, \*\*params) -> TaskRetrieveByNameResponse +- client.tasks.retrieve_by_name(task_name) -> Task - client.tasks.stream_events(task_id) -> object - client.tasks.stream_events_by_name(task_name) -> object @@ -72,7 +72,6 @@ from agentex.types import ( ToolRequestContent, ToolResponseContent, MessageListResponse, - MessageListPaginatedResponse, ) ``` @@ -82,7 +81,6 @@ Methods: - client.messages.retrieve(message_id) -> TaskMessage - client.messages.update(message_id, \*\*params) -> TaskMessage - client.messages.list(\*\*params) -> MessageListResponse -- client.messages.list_paginated(\*\*params) -> MessageListPaginatedResponse ## Batch diff --git a/src/agentex/resources/agents.py b/src/agentex/resources/agents.py index daf0b005..82d7a330 100644 --- a/src/agentex/resources/agents.py +++ b/src/agentex/resources/agents.py @@ -83,10 +83,6 @@ def retrieve( def list( self, *, - limit: int | Omit = omit, - order_by: Optional[str] | Omit = omit, - order_direction: str | Omit = omit, - page_number: int | Omit = omit, task_id: Optional[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. @@ -99,14 +95,6 @@ def list( List all registered agents, optionally filtered by query parameters. Args: - limit: Limit - - order_by: Field to order by - - order_direction: Order direction (asc or desc) - - page_number: Page number - task_id: Task ID extra_headers: Send extra headers @@ -124,16 +112,7 @@ def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=maybe_transform( - { - "limit": limit, - "order_by": order_by, - "order_direction": order_direction, - "page_number": page_number, - "task_id": task_id, - }, - agent_list_params.AgentListParams, - ), + query=maybe_transform({"task_id": task_id}, agent_list_params.AgentListParams), ), cast_to=AgentListResponse, ) @@ -390,10 +369,6 @@ async def retrieve( async def list( self, *, - limit: int | Omit = omit, - order_by: Optional[str] | Omit = omit, - order_direction: str | Omit = omit, - page_number: int | Omit = omit, task_id: Optional[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. @@ -406,14 +381,6 @@ async def list( List all registered agents, optionally filtered by query parameters. Args: - limit: Limit - - order_by: Field to order by - - order_direction: Order direction (asc or desc) - - page_number: Page number - task_id: Task ID extra_headers: Send extra headers @@ -431,16 +398,7 @@ async def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=await async_maybe_transform( - { - "limit": limit, - "order_by": order_by, - "order_direction": order_direction, - "page_number": page_number, - "task_id": task_id, - }, - agent_list_params.AgentListParams, - ), + query=await async_maybe_transform({"task_id": task_id}, agent_list_params.AgentListParams), ), cast_to=AgentListResponse, ) diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index e1256449..d45aa6fa 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -15,12 +15,7 @@ BatchResourceWithStreamingResponse, AsyncBatchResourceWithStreamingResponse, ) -from ...types import ( - message_list_params, - message_create_params, - message_update_params, - message_list_paginated_params, -) +from ...types import message_list_params, message_create_params, message_update_params from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property @@ -35,7 +30,6 @@ from ...types.task_message import TaskMessage from ...types.message_list_response import MessageListResponse from ...types.task_message_content_param import TaskMessageContentParam -from ...types.message_list_paginated_response import MessageListPaginatedResponse __all__ = ["MessagesResource", "AsyncMessagesResource"] @@ -186,10 +180,7 @@ def list( self, *, task_id: str, - limit: int | Omit = omit, - order_by: Optional[str] | Omit = omit, - order_direction: str | Omit = omit, - page_number: int | Omit = omit, + limit: Optional[int] | 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, @@ -198,10 +189,7 @@ def list( timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ - List messages for a task with offset-based pagination. - - For cursor-based pagination with infinite scroll support, use - /messages/paginated. + List Messages Args: task_id: The task ID @@ -225,9 +213,6 @@ def list( { "task_id": task_id, "limit": limit, - "order_by": order_by, - "order_direction": order_direction, - "page_number": page_number, }, message_list_params.MessageListParams, ), @@ -235,70 +220,6 @@ def list( cast_to=MessageListResponse, ) - def list_paginated( - self, - *, - task_id: str, - cursor: Optional[str] | Omit = omit, - direction: Literal["older", "newer"] | Omit = omit, - limit: int | 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, - ) -> MessageListPaginatedResponse: - """ - List messages for a task with cursor-based pagination. - - This endpoint is designed for infinite scroll UIs where new messages may arrive - while paginating through older ones. - - Args: task_id: The task ID to filter messages by limit: Maximum number of - messages to return (default: 50) cursor: Opaque cursor string for pagination. - Pass the `next_cursor` from a previous response to get the next page. direction: - Pagination direction - "older" to get older messages (default), "newer" to get - newer messages. - - Returns: PaginatedMessagesResponse with: - data: List of messages (newest first - when direction="older") - next_cursor: Cursor for fetching the next page (null - if no more pages) - has_more: Whether there are more messages to fetch - - Example: First request: GET /messages/paginated?task_id=xxx&limit=50 Next page: - GET /messages/paginated?task_id=xxx&limit=50&cursor= - - Args: - task_id: The task ID - - 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 - """ - return self._get( - "/messages/paginated", - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - query=maybe_transform( - { - "task_id": task_id, - "cursor": cursor, - "direction": direction, - "limit": limit, - }, - message_list_paginated_params.MessageListPaginatedParams, - ), - ), - cast_to=MessageListPaginatedResponse, - ) - class AsyncMessagesResource(AsyncAPIResource): @cached_property @@ -446,10 +367,7 @@ async def list( self, *, task_id: str, - limit: int | Omit = omit, - order_by: Optional[str] | Omit = omit, - order_direction: str | Omit = omit, - page_number: int | Omit = omit, + limit: Optional[int] | 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, @@ -458,10 +376,7 @@ async def list( timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ - List messages for a task with offset-based pagination. - - For cursor-based pagination with infinite scroll support, use - /messages/paginated. + List Messages Args: task_id: The task ID @@ -485,9 +400,6 @@ async def list( { "task_id": task_id, "limit": limit, - "order_by": order_by, - "order_direction": order_direction, - "page_number": page_number, }, message_list_params.MessageListParams, ), @@ -495,70 +407,6 @@ async def list( cast_to=MessageListResponse, ) - async def list_paginated( - self, - *, - task_id: str, - cursor: Optional[str] | Omit = omit, - direction: Literal["older", "newer"] | Omit = omit, - limit: int | 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, - ) -> MessageListPaginatedResponse: - """ - List messages for a task with cursor-based pagination. - - This endpoint is designed for infinite scroll UIs where new messages may arrive - while paginating through older ones. - - Args: task_id: The task ID to filter messages by limit: Maximum number of - messages to return (default: 50) cursor: Opaque cursor string for pagination. - Pass the `next_cursor` from a previous response to get the next page. direction: - Pagination direction - "older" to get older messages (default), "newer" to get - newer messages. - - Returns: PaginatedMessagesResponse with: - data: List of messages (newest first - when direction="older") - next_cursor: Cursor for fetching the next page (null - if no more pages) - has_more: Whether there are more messages to fetch - - Example: First request: GET /messages/paginated?task_id=xxx&limit=50 Next page: - GET /messages/paginated?task_id=xxx&limit=50&cursor= - - Args: - task_id: The task ID - - 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 - """ - return await self._get( - "/messages/paginated", - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - query=await async_maybe_transform( - { - "task_id": task_id, - "cursor": cursor, - "direction": direction, - "limit": limit, - }, - message_list_paginated_params.MessageListPaginatedParams, - ), - ), - cast_to=MessageListPaginatedResponse, - ) - class MessagesResourceWithRawResponse: def __init__(self, messages: MessagesResource) -> None: @@ -576,9 +424,6 @@ def __init__(self, messages: MessagesResource) -> None: self.list = to_raw_response_wrapper( messages.list, ) - self.list_paginated = to_raw_response_wrapper( - messages.list_paginated, - ) @cached_property def batch(self) -> BatchResourceWithRawResponse: @@ -601,9 +446,6 @@ def __init__(self, messages: AsyncMessagesResource) -> None: self.list = async_to_raw_response_wrapper( messages.list, ) - self.list_paginated = async_to_raw_response_wrapper( - messages.list_paginated, - ) @cached_property def batch(self) -> AsyncBatchResourceWithRawResponse: @@ -626,9 +468,6 @@ def __init__(self, messages: MessagesResource) -> None: self.list = to_streamed_response_wrapper( messages.list, ) - self.list_paginated = to_streamed_response_wrapper( - messages.list_paginated, - ) @cached_property def batch(self) -> BatchResourceWithStreamingResponse: @@ -651,9 +490,6 @@ def __init__(self, messages: AsyncMessagesResource) -> None: self.list = async_to_streamed_response_wrapper( messages.list, ) - self.list_paginated = async_to_streamed_response_wrapper( - messages.list_paginated, - ) @cached_property def batch(self) -> AsyncBatchResourceWithStreamingResponse: diff --git a/src/agentex/resources/spans.py b/src/agentex/resources/spans.py index 589c2ac6..068384c3 100644 --- a/src/agentex/resources/spans.py +++ b/src/agentex/resources/spans.py @@ -222,10 +222,6 @@ def update( def list( self, *, - limit: int | Omit = omit, - order_by: Optional[str] | Omit = omit, - order_direction: str | Omit = omit, - page_number: int | Omit = omit, trace_id: Optional[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. @@ -253,16 +249,7 @@ def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=maybe_transform( - { - "limit": limit, - "order_by": order_by, - "order_direction": order_direction, - "page_number": page_number, - "trace_id": trace_id, - }, - span_list_params.SpanListParams, - ), + query=maybe_transform({"trace_id": trace_id}, span_list_params.SpanListParams), ), cast_to=SpanListResponse, ) @@ -465,10 +452,6 @@ async def update( async def list( self, *, - limit: int | Omit = omit, - order_by: Optional[str] | Omit = omit, - order_direction: str | Omit = omit, - page_number: int | Omit = omit, trace_id: Optional[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. @@ -496,16 +479,7 @@ async def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=await async_maybe_transform( - { - "limit": limit, - "order_by": order_by, - "order_direction": order_direction, - "page_number": page_number, - "trace_id": trace_id, - }, - span_list_params.SpanListParams, - ), + query=await async_maybe_transform({"trace_id": trace_id}, span_list_params.SpanListParams), ), cast_to=SpanListResponse, ) diff --git a/src/agentex/resources/states.py b/src/agentex/resources/states.py index a8f3d085..6196e4e4 100644 --- a/src/agentex/resources/states.py +++ b/src/agentex/resources/states.py @@ -166,10 +166,6 @@ def list( self, *, agent_id: Optional[str] | Omit = omit, - limit: int | Omit = omit, - order_by: Optional[str] | Omit = omit, - order_direction: str | Omit = omit, - page_number: int | Omit = omit, task_id: Optional[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. @@ -184,14 +180,6 @@ def list( Args: agent_id: Agent ID - limit: Limit - - order_by: Field to order by - - order_direction: Order direction (asc or desc) - - page_number: Page number - task_id: Task ID extra_headers: Send extra headers @@ -212,10 +200,6 @@ def list( query=maybe_transform( { "agent_id": agent_id, - "limit": limit, - "order_by": order_by, - "order_direction": order_direction, - "page_number": page_number, "task_id": task_id, }, state_list_params.StateListParams, @@ -400,10 +384,6 @@ async def list( self, *, agent_id: Optional[str] | Omit = omit, - limit: int | Omit = omit, - order_by: Optional[str] | Omit = omit, - order_direction: str | Omit = omit, - page_number: int | Omit = omit, task_id: Optional[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. @@ -418,14 +398,6 @@ async def list( Args: agent_id: Agent ID - limit: Limit - - order_by: Field to order by - - order_direction: Order direction (asc or desc) - - page_number: Page number - task_id: Task ID extra_headers: Send extra headers @@ -446,10 +418,6 @@ async def list( query=await async_maybe_transform( { "agent_id": agent_id, - "limit": limit, - "order_by": order_by, - "order_direction": order_direction, - "page_number": page_number, "task_id": task_id, }, state_list_params.StateListParams, diff --git a/src/agentex/resources/tasks.py b/src/agentex/resources/tasks.py index 1bf41b7b..94e7c866 100644 --- a/src/agentex/resources/tasks.py +++ b/src/agentex/resources/tasks.py @@ -2,12 +2,11 @@ from __future__ import annotations -from typing import List, Optional -from typing_extensions import Literal +from typing import Optional import httpx -from ..types import task_list_params, task_retrieve_params, task_retrieve_by_name_params +from ..types import task_list_params from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property @@ -19,11 +18,10 @@ async_to_streamed_response_wrapper, ) from .._streaming import Stream, AsyncStream +from ..types.task import Task from .._base_client import make_request_options from ..types.task_list_response import TaskListResponse from ..types.shared.delete_response import DeleteResponse -from ..types.task_retrieve_response import TaskRetrieveResponse -from ..types.task_retrieve_by_name_response import TaskRetrieveByNameResponse __all__ = ["TasksResource", "AsyncTasksResource"] @@ -52,14 +50,13 @@ def retrieve( self, task_id: str, *, - relationships: List[Literal["agents"]] | 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, - ) -> TaskRetrieveResponse: + ) -> Task: """ Get a task by its unique ID. @@ -77,13 +74,9 @@ def retrieve( return self._get( f"/tasks/{task_id}", options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - query=maybe_transform({"relationships": relationships}, task_retrieve_params.TaskRetrieveParams), + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=TaskRetrieveResponse, + cast_to=Task, ) def list( @@ -91,11 +84,6 @@ def list( *, agent_id: Optional[str] | Omit = omit, agent_name: Optional[str] | Omit = omit, - limit: int | Omit = omit, - order_by: Optional[str] | Omit = omit, - order_direction: str | Omit = omit, - page_number: int | Omit = omit, - relationships: List[Literal["agents"]] | 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, @@ -126,11 +114,6 @@ def list( { "agent_id": agent_id, "agent_name": agent_name, - "limit": limit, - "order_by": order_by, - "order_direction": order_direction, - "page_number": page_number, - "relationships": relationships, }, task_list_params.TaskListParams, ), @@ -208,14 +191,13 @@ def retrieve_by_name( self, task_name: str, *, - relationships: List[Literal["agents"]] | 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, - ) -> TaskRetrieveByNameResponse: + ) -> Task: """ Get a task by its unique name. @@ -233,15 +215,9 @@ def retrieve_by_name( return self._get( f"/tasks/name/{task_name}", options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - query=maybe_transform( - {"relationships": relationships}, task_retrieve_by_name_params.TaskRetrieveByNameParams - ), + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=TaskRetrieveByNameResponse, + cast_to=Task, ) def stream_events( @@ -339,14 +315,13 @@ async def retrieve( self, task_id: str, *, - relationships: List[Literal["agents"]] | 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, - ) -> TaskRetrieveResponse: + ) -> Task: """ Get a task by its unique ID. @@ -364,15 +339,9 @@ async def retrieve( return await self._get( f"/tasks/{task_id}", options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - query=await async_maybe_transform( - {"relationships": relationships}, task_retrieve_params.TaskRetrieveParams - ), + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=TaskRetrieveResponse, + cast_to=Task, ) async def list( @@ -380,11 +349,6 @@ async def list( *, agent_id: Optional[str] | Omit = omit, agent_name: Optional[str] | Omit = omit, - limit: int | Omit = omit, - order_by: Optional[str] | Omit = omit, - order_direction: str | Omit = omit, - page_number: int | Omit = omit, - relationships: List[Literal["agents"]] | 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, @@ -415,11 +379,6 @@ async def list( { "agent_id": agent_id, "agent_name": agent_name, - "limit": limit, - "order_by": order_by, - "order_direction": order_direction, - "page_number": page_number, - "relationships": relationships, }, task_list_params.TaskListParams, ), @@ -497,14 +456,13 @@ async def retrieve_by_name( self, task_name: str, *, - relationships: List[Literal["agents"]] | 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, - ) -> TaskRetrieveByNameResponse: + ) -> Task: """ Get a task by its unique name. @@ -522,15 +480,9 @@ async def retrieve_by_name( return await self._get( f"/tasks/name/{task_name}", options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - query=await async_maybe_transform( - {"relationships": relationships}, task_retrieve_by_name_params.TaskRetrieveByNameParams - ), + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=TaskRetrieveByNameResponse, + cast_to=Task, ) async def stream_events( diff --git a/src/agentex/resources/tracker.py b/src/agentex/resources/tracker.py index 15906b3f..089e6a62 100644 --- a/src/agentex/resources/tracker.py +++ b/src/agentex/resources/tracker.py @@ -131,10 +131,6 @@ def list( self, *, agent_id: Optional[str] | Omit = omit, - limit: int | Omit = omit, - order_by: Optional[str] | Omit = omit, - order_direction: str | Omit = omit, - page_number: int | Omit = omit, task_id: Optional[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. @@ -149,14 +145,6 @@ def list( Args: agent_id: Agent ID - limit: Limit - - order_by: Field to order by - - order_direction: Order direction (asc or desc) - - page_number: Page number - task_id: Task ID extra_headers: Send extra headers @@ -177,10 +165,6 @@ def list( query=maybe_transform( { "agent_id": agent_id, - "limit": limit, - "order_by": order_by, - "order_direction": order_direction, - "page_number": page_number, "task_id": task_id, }, tracker_list_params.TrackerListParams, @@ -297,10 +281,6 @@ async def list( self, *, agent_id: Optional[str] | Omit = omit, - limit: int | Omit = omit, - order_by: Optional[str] | Omit = omit, - order_direction: str | Omit = omit, - page_number: int | Omit = omit, task_id: Optional[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. @@ -315,14 +295,6 @@ async def list( Args: agent_id: Agent ID - limit: Limit - - order_by: Field to order by - - order_direction: Order direction (asc or desc) - - page_number: Page number - task_id: Task ID extra_headers: Send extra headers @@ -343,10 +315,6 @@ async def list( query=await async_maybe_transform( { "agent_id": agent_id, - "limit": limit, - "order_by": order_by, - "order_direction": order_direction, - "page_number": page_number, "task_id": task_id, }, tracker_list_params.TrackerListParams, diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 8628bd3c..0445dfad 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -45,7 +45,6 @@ from .tool_response_delta import ToolResponseDelta as ToolResponseDelta from .tracker_list_params import TrackerListParams as TrackerListParams from .task_message_content import TaskMessageContent as TaskMessageContent -from .task_retrieve_params import TaskRetrieveParams as TaskRetrieveParams from .tool_request_content import ToolRequestContent as ToolRequestContent from .message_create_params import MessageCreateParams as MessageCreateParams from .message_list_response import MessageListResponse as MessageListResponse @@ -53,7 +52,6 @@ from .tool_response_content import ToolResponseContent as ToolResponseContent from .tracker_list_response import TrackerListResponse as TrackerListResponse from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams -from .task_retrieve_response import TaskRetrieveResponse as TaskRetrieveResponse from .reasoning_content_delta import ReasoningContentDelta as ReasoningContentDelta from .reasoning_content_param import ReasoningContentParam as ReasoningContentParam from .reasoning_summary_delta import ReasoningSummaryDelta as ReasoningSummaryDelta @@ -61,7 +59,3 @@ from .task_message_content_param import TaskMessageContentParam as TaskMessageContentParam from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam -from .task_retrieve_by_name_params import TaskRetrieveByNameParams as TaskRetrieveByNameParams -from .message_list_paginated_params import MessageListPaginatedParams as MessageListPaginatedParams -from .task_retrieve_by_name_response import TaskRetrieveByNameResponse as TaskRetrieveByNameResponse -from .message_list_paginated_response import MessageListPaginatedResponse as MessageListPaginatedResponse diff --git a/src/agentex/types/acp_type.py b/src/agentex/types/acp_type.py index 8b70a292..ec86ddf5 100644 --- a/src/agentex/types/acp_type.py +++ b/src/agentex/types/acp_type.py @@ -4,4 +4,4 @@ __all__ = ["AcpType"] -AcpType: TypeAlias = Literal["sync", "async", "agentic"] +AcpType: TypeAlias = Literal["sync", "agentic"] diff --git a/src/agentex/types/agent.py b/src/agentex/types/agent.py index 7828822c..731332ab 100644 --- a/src/agentex/types/agent.py +++ b/src/agentex/types/agent.py @@ -15,7 +15,7 @@ class Agent(BaseModel): """The unique identifier of the agent.""" acp_type: AcpType - """The type of the ACP Server (Either sync or async)""" + """The type of the ACP Server (Either sync or agentic)""" created_at: datetime """The timestamp when the agent was created""" @@ -29,16 +29,13 @@ class Agent(BaseModel): updated_at: datetime """The timestamp when the agent was last updated""" - agent_input_type: Optional[Literal["text", "json"]] = None - """The type of input the agent expects.""" - registered_at: Optional[datetime] = None """The timestamp when the agent was last registered""" registration_metadata: Optional[Dict[str, object]] = None """The metadata for the agent's registration.""" - status: Optional[Literal["Ready", "Failed", "Unknown", "Deleted", "Unhealthy"]] = None + status: Optional[Literal["Ready", "Failed", "Unknown", "Deleted"]] = None """The status of the action, indicating if it's building, ready, failed, etc.""" status_reason: Optional[str] = None diff --git a/src/agentex/types/agent_list_params.py b/src/agentex/types/agent_list_params.py index 084fdfae..b432174a 100644 --- a/src/agentex/types/agent_list_params.py +++ b/src/agentex/types/agent_list_params.py @@ -9,17 +9,5 @@ class AgentListParams(TypedDict, total=False): - limit: int - """Limit""" - - order_by: Optional[str] - """Field to order by""" - - order_direction: str - """Order direction (asc or desc)""" - - page_number: int - """Page number""" - task_id: Optional[str] """Task ID""" diff --git a/src/agentex/types/message_list_paginated_params.py b/src/agentex/types/message_list_paginated_params.py deleted file mode 100644 index 6dfe1e7e..00000000 --- a/src/agentex/types/message_list_paginated_params.py +++ /dev/null @@ -1,19 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Optional -from typing_extensions import Literal, Required, TypedDict - -__all__ = ["MessageListPaginatedParams"] - - -class MessageListPaginatedParams(TypedDict, total=False): - task_id: Required[str] - """The task ID""" - - cursor: Optional[str] - - direction: Literal["older", "newer"] - - limit: int diff --git a/src/agentex/types/message_list_paginated_response.py b/src/agentex/types/message_list_paginated_response.py deleted file mode 100644 index 40af0b4a..00000000 --- a/src/agentex/types/message_list_paginated_response.py +++ /dev/null @@ -1,21 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import List, Optional - -from .._models import BaseModel -from .task_message import TaskMessage - -__all__ = ["MessageListPaginatedResponse"] - - -class MessageListPaginatedResponse(BaseModel): - """Response with cursor pagination metadata.""" - - data: List[TaskMessage] - """List of messages""" - - has_more: Optional[bool] = None - """Whether there are more messages to fetch""" - - next_cursor: Optional[str] = None - """Cursor for fetching the next page of older messages""" diff --git a/src/agentex/types/message_list_params.py b/src/agentex/types/message_list_params.py index 87027eed..4911bfa9 100644 --- a/src/agentex/types/message_list_params.py +++ b/src/agentex/types/message_list_params.py @@ -12,10 +12,4 @@ class MessageListParams(TypedDict, total=False): task_id: Required[str] """The task ID""" - limit: int - - order_by: Optional[str] - - order_direction: str - - page_number: int + limit: Optional[int] diff --git a/src/agentex/types/span_list_params.py b/src/agentex/types/span_list_params.py index 40d4d651..35218965 100644 --- a/src/agentex/types/span_list_params.py +++ b/src/agentex/types/span_list_params.py @@ -9,12 +9,4 @@ class SpanListParams(TypedDict, total=False): - limit: int - - order_by: Optional[str] - - order_direction: str - - page_number: int - trace_id: Optional[str] diff --git a/src/agentex/types/state_list_params.py b/src/agentex/types/state_list_params.py index 9cb7d3dc..6034d345 100644 --- a/src/agentex/types/state_list_params.py +++ b/src/agentex/types/state_list_params.py @@ -12,17 +12,5 @@ class StateListParams(TypedDict, total=False): agent_id: Optional[str] """Agent ID""" - limit: int - """Limit""" - - order_by: Optional[str] - """Field to order by""" - - order_direction: str - """Order direction (asc or desc)""" - - page_number: int - """Page number""" - task_id: Optional[str] """Task ID""" diff --git a/src/agentex/types/task_list_params.py b/src/agentex/types/task_list_params.py index e41bf821..f8bc3364 100644 --- a/src/agentex/types/task_list_params.py +++ b/src/agentex/types/task_list_params.py @@ -2,8 +2,8 @@ from __future__ import annotations -from typing import List, Optional -from typing_extensions import Literal, TypedDict +from typing import Optional +from typing_extensions import TypedDict __all__ = ["TaskListParams"] @@ -12,13 +12,3 @@ class TaskListParams(TypedDict, total=False): agent_id: Optional[str] agent_name: Optional[str] - - limit: int - - order_by: Optional[str] - - order_direction: str - - page_number: int - - relationships: List[Literal["agents"]] diff --git a/src/agentex/types/task_list_response.py b/src/agentex/types/task_list_response.py index 85f87c0e..c9607e60 100644 --- a/src/agentex/types/task_list_response.py +++ b/src/agentex/types/task_list_response.py @@ -1,35 +1,10 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Dict, List, Optional -from datetime import datetime -from typing_extensions import Literal, TypeAlias +from typing import List +from typing_extensions import TypeAlias -from .agent import Agent -from .._models import BaseModel +from .task import Task -__all__ = ["TaskListResponse", "TaskListResponseItem"] +__all__ = ["TaskListResponse"] - -class TaskListResponseItem(BaseModel): - """Task response model with optional related data based on relationships""" - - id: str - - agents: Optional[List[Agent]] = None - - created_at: Optional[datetime] = None - - name: Optional[str] = None - - params: Optional[Dict[str, object]] = None - - status: Optional[Literal["CANCELED", "COMPLETED", "FAILED", "RUNNING", "TERMINATED", "TIMED_OUT", "DELETED"]] = None - - status_reason: Optional[str] = None - - task_metadata: Optional[Dict[str, object]] = None - - updated_at: Optional[datetime] = None - - -TaskListResponse: TypeAlias = List[TaskListResponseItem] +TaskListResponse: TypeAlias = List[Task] diff --git a/src/agentex/types/task_retrieve_by_name_params.py b/src/agentex/types/task_retrieve_by_name_params.py deleted file mode 100644 index 98d03982..00000000 --- a/src/agentex/types/task_retrieve_by_name_params.py +++ /dev/null @@ -1,12 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import List -from typing_extensions import Literal, TypedDict - -__all__ = ["TaskRetrieveByNameParams"] - - -class TaskRetrieveByNameParams(TypedDict, total=False): - relationships: List[Literal["agents"]] diff --git a/src/agentex/types/task_retrieve_by_name_response.py b/src/agentex/types/task_retrieve_by_name_response.py deleted file mode 100644 index 1ffc6819..00000000 --- a/src/agentex/types/task_retrieve_by_name_response.py +++ /dev/null @@ -1,32 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import Dict, List, Optional -from datetime import datetime -from typing_extensions import Literal - -from .agent import Agent -from .._models import BaseModel - -__all__ = ["TaskRetrieveByNameResponse"] - - -class TaskRetrieveByNameResponse(BaseModel): - """Task response model with optional related data based on relationships""" - - id: str - - agents: Optional[List[Agent]] = None - - created_at: Optional[datetime] = None - - name: Optional[str] = None - - params: Optional[Dict[str, object]] = None - - status: Optional[Literal["CANCELED", "COMPLETED", "FAILED", "RUNNING", "TERMINATED", "TIMED_OUT", "DELETED"]] = None - - status_reason: Optional[str] = None - - task_metadata: Optional[Dict[str, object]] = None - - updated_at: Optional[datetime] = None diff --git a/src/agentex/types/task_retrieve_params.py b/src/agentex/types/task_retrieve_params.py deleted file mode 100644 index 61748a1b..00000000 --- a/src/agentex/types/task_retrieve_params.py +++ /dev/null @@ -1,12 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import List -from typing_extensions import Literal, TypedDict - -__all__ = ["TaskRetrieveParams"] - - -class TaskRetrieveParams(TypedDict, total=False): - relationships: List[Literal["agents"]] diff --git a/src/agentex/types/task_retrieve_response.py b/src/agentex/types/task_retrieve_response.py deleted file mode 100644 index 5f262946..00000000 --- a/src/agentex/types/task_retrieve_response.py +++ /dev/null @@ -1,32 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import Dict, List, Optional -from datetime import datetime -from typing_extensions import Literal - -from .agent import Agent -from .._models import BaseModel - -__all__ = ["TaskRetrieveResponse"] - - -class TaskRetrieveResponse(BaseModel): - """Task response model with optional related data based on relationships""" - - id: str - - agents: Optional[List[Agent]] = None - - created_at: Optional[datetime] = None - - name: Optional[str] = None - - params: Optional[Dict[str, object]] = None - - status: Optional[Literal["CANCELED", "COMPLETED", "FAILED", "RUNNING", "TERMINATED", "TIMED_OUT", "DELETED"]] = None - - status_reason: Optional[str] = None - - task_metadata: Optional[Dict[str, object]] = None - - updated_at: Optional[datetime] = None diff --git a/src/agentex/types/tracker_list_params.py b/src/agentex/types/tracker_list_params.py index 57234f4a..47b4da7b 100644 --- a/src/agentex/types/tracker_list_params.py +++ b/src/agentex/types/tracker_list_params.py @@ -12,17 +12,5 @@ class TrackerListParams(TypedDict, total=False): agent_id: Optional[str] """Agent ID""" - limit: int - """Limit""" - - order_by: Optional[str] - """Field to order by""" - - order_direction: str - """Order direction (asc or desc)""" - - page_number: int - """Page number""" - task_id: Optional[str] """Task ID""" diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index 340238ba..7ef11072 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -74,10 +74,6 @@ def test_method_list(self, client: Agentex) -> None: @parametrize def test_method_list_with_all_params(self, client: Agentex) -> None: agent = client.agents.list( - limit=1, - order_by="order_by", - order_direction="order_direction", - page_number=1, task_id="task_id", ) assert_matches_type(AgentListResponse, agent, path=["response"]) @@ -418,10 +414,6 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: @parametrize async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.list( - limit=1, - order_by="order_by", - order_direction="order_direction", - page_number=1, task_id="task_id", ) assert_matches_type(AgentListResponse, agent, path=["response"]) diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py index 4b234334..457d3e24 100644 --- a/tests/api_resources/test_messages.py +++ b/tests/api_resources/test_messages.py @@ -12,7 +12,6 @@ from agentex.types import ( TaskMessage, MessageListResponse, - MessageListPaginatedResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -241,9 +240,6 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: message = client.messages.list( task_id="task_id", limit=0, - order_by="order_by", - order_direction="order_direction", - page_number=0, ) assert_matches_type(MessageListResponse, message, path=["response"]) @@ -273,51 +269,6 @@ def test_streaming_response_list(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_list_paginated(self, client: Agentex) -> None: - message = client.messages.list_paginated( - task_id="task_id", - ) - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_list_paginated_with_all_params(self, client: Agentex) -> None: - message = client.messages.list_paginated( - task_id="task_id", - cursor="cursor", - direction="older", - limit=0, - ) - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_raw_response_list_paginated(self, client: Agentex) -> None: - response = client.messages.with_raw_response.list_paginated( - task_id="task_id", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - message = response.parse() - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_streaming_response_list_paginated(self, client: Agentex) -> None: - with client.messages.with_streaming_response.list_paginated( - task_id="task_id", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - message = response.parse() - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - assert cast(Any, response.is_closed) is True - class TestAsyncMessages: parametrize = pytest.mark.parametrize( @@ -544,9 +495,6 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> message = await async_client.messages.list( task_id="task_id", limit=0, - order_by="order_by", - order_direction="order_direction", - page_number=0, ) assert_matches_type(MessageListResponse, message, path=["response"]) @@ -575,48 +523,3 @@ async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None assert_matches_type(MessageListResponse, message, path=["response"]) assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_list_paginated(self, async_client: AsyncAgentex) -> None: - message = await async_client.messages.list_paginated( - task_id="task_id", - ) - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_list_paginated_with_all_params(self, async_client: AsyncAgentex) -> None: - message = await async_client.messages.list_paginated( - task_id="task_id", - cursor="cursor", - direction="older", - limit=0, - ) - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_raw_response_list_paginated(self, async_client: AsyncAgentex) -> None: - response = await async_client.messages.with_raw_response.list_paginated( - task_id="task_id", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - message = await response.parse() - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_streaming_response_list_paginated(self, async_client: AsyncAgentex) -> None: - async with async_client.messages.with_streaming_response.list_paginated( - task_id="task_id", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - message = await response.parse() - assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) - - assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_spans.py b/tests/api_resources/test_spans.py index ef991d4e..b9c9b168 100644 --- a/tests/api_resources/test_spans.py +++ b/tests/api_resources/test_spans.py @@ -184,10 +184,6 @@ def test_method_list(self, client: Agentex) -> None: @parametrize def test_method_list_with_all_params(self, client: Agentex) -> None: span = client.spans.list( - limit=0, - order_by="order_by", - order_direction="order_direction", - page_number=0, trace_id="trace_id", ) assert_matches_type(SpanListResponse, span, path=["response"]) @@ -386,10 +382,6 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: @parametrize async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.list( - limit=0, - order_by="order_by", - order_direction="order_direction", - page_number=0, trace_id="trace_id", ) assert_matches_type(SpanListResponse, span, path=["response"]) diff --git a/tests/api_resources/test_states.py b/tests/api_resources/test_states.py index c8cfd84c..b23ff49a 100644 --- a/tests/api_resources/test_states.py +++ b/tests/api_resources/test_states.py @@ -164,10 +164,6 @@ def test_method_list(self, client: Agentex) -> None: def test_method_list_with_all_params(self, client: Agentex) -> None: state = client.states.list( agent_id="agent_id", - limit=1, - order_by="order_by", - order_direction="order_direction", - page_number=1, task_id="task_id", ) assert_matches_type(StateListResponse, state, path=["response"]) @@ -389,10 +385,6 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: state = await async_client.states.list( agent_id="agent_id", - limit=1, - order_by="order_by", - order_direction="order_direction", - page_number=1, task_id="task_id", ) assert_matches_type(StateListResponse, state, path=["response"]) diff --git a/tests/api_resources/test_tasks.py b/tests/api_resources/test_tasks.py index 6c2f2c54..ac858a80 100644 --- a/tests/api_resources/test_tasks.py +++ b/tests/api_resources/test_tasks.py @@ -9,11 +9,7 @@ from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type -from agentex.types import ( - TaskListResponse, - TaskRetrieveResponse, - TaskRetrieveByNameResponse, -) +from agentex.types import Task, TaskListResponse from agentex.types.shared import DeleteResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -26,42 +22,33 @@ class TestTasks: @parametrize def test_method_retrieve(self, client: Agentex) -> None: task = client.tasks.retrieve( - task_id="task_id", - ) - assert_matches_type(TaskRetrieveResponse, task, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_retrieve_with_all_params(self, client: Agentex) -> None: - task = client.tasks.retrieve( - task_id="task_id", - relationships=["agents"], + "task_id", ) - assert_matches_type(TaskRetrieveResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.tasks.with_raw_response.retrieve( - task_id="task_id", + "task_id", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(TaskRetrieveResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.tasks.with_streaming_response.retrieve( - task_id="task_id", + "task_id", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(TaskRetrieveResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -70,7 +57,7 @@ def test_streaming_response_retrieve(self, client: Agentex) -> None: def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): client.tasks.with_raw_response.retrieve( - task_id="", + "", ) @pytest.mark.skip(reason="Prism tests are disabled") @@ -85,11 +72,6 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: task = client.tasks.list( agent_id="agent_id", agent_name="agent_name", - limit=0, - order_by="order_by", - order_direction="order_direction", - page_number=0, - relationships=["agents"], ) assert_matches_type(TaskListResponse, task, path=["response"]) @@ -203,42 +185,33 @@ def test_path_params_delete_by_name(self, client: Agentex) -> None: @parametrize def test_method_retrieve_by_name(self, client: Agentex) -> None: task = client.tasks.retrieve_by_name( - task_name="task_name", - ) - assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_retrieve_by_name_with_all_params(self, client: Agentex) -> None: - task = client.tasks.retrieve_by_name( - task_name="task_name", - relationships=["agents"], + "task_name", ) - assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve_by_name(self, client: Agentex) -> None: response = client.tasks.with_raw_response.retrieve_by_name( - task_name="task_name", + "task_name", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve_by_name(self, client: Agentex) -> None: with client.tasks.with_streaming_response.retrieve_by_name( - task_name="task_name", + "task_name", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -247,7 +220,7 @@ def test_streaming_response_retrieve_by_name(self, client: Agentex) -> None: def test_path_params_retrieve_by_name(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): client.tasks.with_raw_response.retrieve_by_name( - task_name="", + "", ) @pytest.mark.skip(reason="Prism tests are disabled") @@ -342,42 +315,33 @@ class TestAsyncTasks: @parametrize async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.retrieve( - task_id="task_id", - ) - assert_matches_type(TaskRetrieveResponse, task, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_retrieve_with_all_params(self, async_client: AsyncAgentex) -> None: - task = await async_client.tasks.retrieve( - task_id="task_id", - relationships=["agents"], + "task_id", ) - assert_matches_type(TaskRetrieveResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.retrieve( - task_id="task_id", + "task_id", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(TaskRetrieveResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.retrieve( - task_id="task_id", + "task_id", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(TaskRetrieveResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -386,7 +350,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): await async_client.tasks.with_raw_response.retrieve( - task_id="", + "", ) @pytest.mark.skip(reason="Prism tests are disabled") @@ -401,11 +365,6 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> task = await async_client.tasks.list( agent_id="agent_id", agent_name="agent_name", - limit=0, - order_by="order_by", - order_direction="order_direction", - page_number=0, - relationships=["agents"], ) assert_matches_type(TaskListResponse, task, path=["response"]) @@ -519,42 +478,33 @@ async def test_path_params_delete_by_name(self, async_client: AsyncAgentex) -> N @parametrize async def test_method_retrieve_by_name(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.retrieve_by_name( - task_name="task_name", - ) - assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_retrieve_by_name_with_all_params(self, async_client: AsyncAgentex) -> None: - task = await async_client.tasks.retrieve_by_name( - task_name="task_name", - relationships=["agents"], + "task_name", ) - assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve_by_name(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.retrieve_by_name( - task_name="task_name", + "task_name", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve_by_name(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.retrieve_by_name( - task_name="task_name", + "task_name", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) + assert_matches_type(Task, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -563,7 +513,7 @@ async def test_streaming_response_retrieve_by_name(self, async_client: AsyncAgen async def test_path_params_retrieve_by_name(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): await async_client.tasks.with_raw_response.retrieve_by_name( - task_name="", + "", ) @pytest.mark.skip(reason="Prism tests are disabled") diff --git a/tests/api_resources/test_tracker.py b/tests/api_resources/test_tracker.py index 5ea656f6..431508c3 100644 --- a/tests/api_resources/test_tracker.py +++ b/tests/api_resources/test_tracker.py @@ -123,10 +123,6 @@ def test_method_list(self, client: Agentex) -> None: def test_method_list_with_all_params(self, client: Agentex) -> None: tracker = client.tracker.list( agent_id="agent_id", - limit=1, - order_by="order_by", - order_direction="order_direction", - page_number=1, task_id="task_id", ) assert_matches_type(TrackerListResponse, tracker, path=["response"]) @@ -265,10 +261,6 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: tracker = await async_client.tracker.list( agent_id="agent_id", - limit=1, - order_by="order_by", - order_direction="order_direction", - page_number=1, task_id="task_id", ) assert_matches_type(TrackerListResponse, tracker, path=["response"]) From 1f35c3acea137fb022f7574eb709a4b0a2a2a6c2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Dec 2025 07:32:24 +0000 Subject: [PATCH 1076/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2cff198e..1f75b40f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 32eb65911c08ac84d117cecdf2759869 From efb9cd261f83879661f5854fe418283d471a002f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Dec 2025 08:32:23 +0000 Subject: [PATCH 1077/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f75b40f..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 From 88fd62fd8277e8796dd4da461c2630423e94b7cb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Dec 2025 12:32:01 +0000 Subject: [PATCH 1078/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2cff198e..1f75b40f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 32eb65911c08ac84d117cecdf2759869 From 93702f0e7f17ff77f5a71659220ce868331e50d7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Dec 2025 15:32:13 +0000 Subject: [PATCH 1079/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f75b40f..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 From 37d51ed72d1f36890a1e8fb97f0152f805068186 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Dec 2025 16:32:12 +0000 Subject: [PATCH 1080/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2cff198e..1f75b40f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 32eb65911c08ac84d117cecdf2759869 From 3b1d7326a1e3bcc2895b0612e3b78b5f5a27d708 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Dec 2025 18:31:56 +0000 Subject: [PATCH 1081/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f75b40f..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 From e96efb836c4f387283c7d05d04b0905c1d72eea7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Dec 2025 19:32:07 +0000 Subject: [PATCH 1082/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2cff198e..1f75b40f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 32eb65911c08ac84d117cecdf2759869 From c0a9a88d1192ded2401b7063bd4bcc0706b0afbd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 13 Dec 2025 23:32:07 +0000 Subject: [PATCH 1083/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f75b40f..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 From 1b37eec120d45f7310d2b8b3dd42c3dfdcdd3db5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Dec 2025 02:32:25 +0000 Subject: [PATCH 1084/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2cff198e..1f75b40f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 32eb65911c08ac84d117cecdf2759869 From b52452f5769d063db232b02b50e5d22778b3c534 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Dec 2025 04:32:07 +0000 Subject: [PATCH 1085/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f75b40f..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 From 41e0d7522e3f0d5cf7c72251b8a8f44cb40c8e3a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Dec 2025 10:32:23 +0000 Subject: [PATCH 1086/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2cff198e..1f75b40f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 32eb65911c08ac84d117cecdf2759869 From cf83bbb40f7fd34e7021e0a22ebc691a39daa9e4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Dec 2025 13:32:07 +0000 Subject: [PATCH 1087/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f75b40f..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 From 46fa012bd73f06758f14b9b6ed871e5fcab43b4c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Dec 2025 14:32:11 +0000 Subject: [PATCH 1088/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2cff198e..1f75b40f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 32eb65911c08ac84d117cecdf2759869 From c886a972fc3e351b549567914775d03e139271bf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Dec 2025 17:32:18 +0000 Subject: [PATCH 1089/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f75b40f..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 From 140719279a51f03c2d185e8f4a2e628785e19303 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Dec 2025 18:32:17 +0000 Subject: [PATCH 1090/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2cff198e..1f75b40f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 32eb65911c08ac84d117cecdf2759869 From 00464553fd8c31e4ec77cf95f00de9fc780fce7b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Dec 2025 21:32:05 +0000 Subject: [PATCH 1091/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f75b40f..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 From 1939b0765dbfcb47c28b2ba8cd9fa487daf42d43 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sun, 14 Dec 2025 23:32:06 +0000 Subject: [PATCH 1092/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2cff198e..1f75b40f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 32eb65911c08ac84d117cecdf2759869 From 5a78518c921fd4ea6757d62f5c8365216ef8369a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Dec 2025 02:32:24 +0000 Subject: [PATCH 1093/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f75b40f..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 From 1389bca1aa8db2bf8b62520c000fd6b6f42eadee Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Dec 2025 03:32:22 +0000 Subject: [PATCH 1094/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2cff198e..1f75b40f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 32eb65911c08ac84d117cecdf2759869 From 15642844ac08fac02b32f58c4583ef5f807f55df Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Dec 2025 04:32:25 +0000 Subject: [PATCH 1095/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f75b40f..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 From 82e8e3b1722f645580398aa7259ca096cba89b3c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Dec 2025 06:32:14 +0000 Subject: [PATCH 1096/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2cff198e..1f75b40f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 32eb65911c08ac84d117cecdf2759869 From 35e3e0f584d5d1573b41323d1c8adfd4fbd634fd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Dec 2025 07:32:16 +0000 Subject: [PATCH 1097/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f75b40f..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 From 86d9dba64b1a0125ad517db1d0e62c07f424d99f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Dec 2025 08:32:06 +0000 Subject: [PATCH 1098/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2cff198e..1f75b40f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 32eb65911c08ac84d117cecdf2759869 From 90b88ad77885112f04605413bca035d15dc938c3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Dec 2025 09:32:10 +0000 Subject: [PATCH 1099/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f75b40f..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 From dbc1fe05a9fc081976faf477b62bfd8f4a312176 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Dec 2025 10:32:12 +0000 Subject: [PATCH 1100/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2cff198e..1f75b40f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 32eb65911c08ac84d117cecdf2759869 From 78e22a06f420742328ced4ee0fa9d140548e108b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Dec 2025 11:32:18 +0000 Subject: [PATCH 1101/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f75b40f..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 From d92af80dff77d7cdf00e19d8185eb4d77b9b8d6a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Dec 2025 12:32:18 +0000 Subject: [PATCH 1102/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2cff198e..1f75b40f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 32eb65911c08ac84d117cecdf2759869 From adc226d8dab64c8a7d7db9832dcea5d5b42c90f5 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Dec 2025 13:32:23 +0000 Subject: [PATCH 1103/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f75b40f..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 From c7af72eca98a6d2d85d32a9cb0171244632ddc49 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Dec 2025 15:32:02 +0000 Subject: [PATCH 1104/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 2cff198e..1f75b40f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml +openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f config_hash: 32eb65911c08ac84d117cecdf2759869 From 828bea4fdc07ef1d89f0859ce192228e5f10aea4 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Dec 2025 16:32:19 +0000 Subject: [PATCH 1105/1108] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 1f75b40f..2cff198e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-03963937874221f124e7a52b2640b8eb69d5ad3e0dafea5d4e65dd3ebb4c06b3.yml -openapi_spec_hash: db2c598ad7459cbeb3d5dbf812b0ff6f +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml +openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 config_hash: 32eb65911c08ac84d117cecdf2759869 From 41feb419672051bee5d0e16a28b906791f073ad8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Dec 2025 17:32:18 +0000 Subject: [PATCH 1106/1108] feat(api): api update --- .stats.yml | 6 +- api.md | 8 +- src/agentex/resources/agents.py | 46 ++++- src/agentex/resources/messages/messages.py | 174 +++++++++++++++++- src/agentex/resources/spans.py | 30 ++- src/agentex/resources/states.py | 32 ++++ src/agentex/resources/tasks.py | 78 ++++++-- src/agentex/resources/tracker.py | 32 ++++ src/agentex/types/__init__.py | 6 + src/agentex/types/acp_type.py | 2 +- src/agentex/types/agent.py | 7 +- src/agentex/types/agent_list_params.py | 12 ++ .../types/message_list_paginated_params.py | 19 ++ .../types/message_list_paginated_response.py | 21 +++ src/agentex/types/message_list_params.py | 8 +- src/agentex/types/span_list_params.py | 8 + src/agentex/types/state_list_params.py | 12 ++ src/agentex/types/task_list_params.py | 14 +- src/agentex/types/task_list_response.py | 35 +++- .../types/task_retrieve_by_name_params.py | 12 ++ .../types/task_retrieve_by_name_response.py | 32 ++++ src/agentex/types/task_retrieve_params.py | 12 ++ src/agentex/types/task_retrieve_response.py | 32 ++++ src/agentex/types/tracker_list_params.py | 12 ++ tests/api_resources/test_agents.py | 8 + tests/api_resources/test_messages.py | 97 ++++++++++ tests/api_resources/test_spans.py | 8 + tests/api_resources/test_states.py | 8 + tests/api_resources/test_tasks.py | 108 ++++++++--- tests/api_resources/test_tracker.py | 8 + 30 files changed, 817 insertions(+), 70 deletions(-) create mode 100644 src/agentex/types/message_list_paginated_params.py create mode 100644 src/agentex/types/message_list_paginated_response.py create mode 100644 src/agentex/types/task_retrieve_by_name_params.py create mode 100644 src/agentex/types/task_retrieve_by_name_response.py create mode 100644 src/agentex/types/task_retrieve_params.py create mode 100644 src/agentex/types/task_retrieve_response.py diff --git a/.stats.yml b/.stats.yml index 2cff198e..fbcaba61 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 34 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-c34c0577d9716c22554633ecb41d091675248d1385e9d1cc7c19479d55b56cb1.yml -openapi_spec_hash: 3daaeab87b12b271ba2ee39e7dc166f2 +configured_endpoints: 35 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-8f9296ac9fa68bb264c4739463e55ce27cdafb31b705b27600d6656db7b0dac5.yml +openapi_spec_hash: 47f4675ac3c7198869240b5c6f33f8fd config_hash: 32eb65911c08ac84d117cecdf2759869 diff --git a/api.md b/api.md index 4e3e6f83..7e8e6800 100644 --- a/api.md +++ b/api.md @@ -43,16 +43,16 @@ Methods: Types: ```python -from agentex.types import Task, TaskListResponse +from agentex.types import Task, TaskRetrieveResponse, TaskListResponse, TaskRetrieveByNameResponse ``` Methods: -- client.tasks.retrieve(task_id) -> Task +- client.tasks.retrieve(task_id, \*\*params) -> TaskRetrieveResponse - client.tasks.list(\*\*params) -> TaskListResponse - client.tasks.delete(task_id) -> DeleteResponse - client.tasks.delete_by_name(task_name) -> DeleteResponse -- client.tasks.retrieve_by_name(task_name) -> Task +- client.tasks.retrieve_by_name(task_name, \*\*params) -> TaskRetrieveByNameResponse - client.tasks.stream_events(task_id) -> object - client.tasks.stream_events_by_name(task_name) -> object @@ -72,6 +72,7 @@ from agentex.types import ( ToolRequestContent, ToolResponseContent, MessageListResponse, + MessageListPaginatedResponse, ) ``` @@ -81,6 +82,7 @@ Methods: - client.messages.retrieve(message_id) -> TaskMessage - client.messages.update(message_id, \*\*params) -> TaskMessage - client.messages.list(\*\*params) -> MessageListResponse +- client.messages.list_paginated(\*\*params) -> MessageListPaginatedResponse ## Batch diff --git a/src/agentex/resources/agents.py b/src/agentex/resources/agents.py index 82d7a330..daf0b005 100644 --- a/src/agentex/resources/agents.py +++ b/src/agentex/resources/agents.py @@ -83,6 +83,10 @@ def retrieve( def list( self, *, + limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, + page_number: int | Omit = omit, task_id: Optional[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. @@ -95,6 +99,14 @@ def list( List all registered agents, optionally filtered by query parameters. Args: + limit: Limit + + order_by: Field to order by + + order_direction: Order direction (asc or desc) + + page_number: Page number + task_id: Task ID extra_headers: Send extra headers @@ -112,7 +124,16 @@ def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=maybe_transform({"task_id": task_id}, agent_list_params.AgentListParams), + query=maybe_transform( + { + "limit": limit, + "order_by": order_by, + "order_direction": order_direction, + "page_number": page_number, + "task_id": task_id, + }, + agent_list_params.AgentListParams, + ), ), cast_to=AgentListResponse, ) @@ -369,6 +390,10 @@ async def retrieve( async def list( self, *, + limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, + page_number: int | Omit = omit, task_id: Optional[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. @@ -381,6 +406,14 @@ async def list( List all registered agents, optionally filtered by query parameters. Args: + limit: Limit + + order_by: Field to order by + + order_direction: Order direction (asc or desc) + + page_number: Page number + task_id: Task ID extra_headers: Send extra headers @@ -398,7 +431,16 @@ async def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=await async_maybe_transform({"task_id": task_id}, agent_list_params.AgentListParams), + query=await async_maybe_transform( + { + "limit": limit, + "order_by": order_by, + "order_direction": order_direction, + "page_number": page_number, + "task_id": task_id, + }, + agent_list_params.AgentListParams, + ), ), cast_to=AgentListResponse, ) diff --git a/src/agentex/resources/messages/messages.py b/src/agentex/resources/messages/messages.py index d45aa6fa..e1256449 100644 --- a/src/agentex/resources/messages/messages.py +++ b/src/agentex/resources/messages/messages.py @@ -15,7 +15,12 @@ BatchResourceWithStreamingResponse, AsyncBatchResourceWithStreamingResponse, ) -from ...types import message_list_params, message_create_params, message_update_params +from ...types import ( + message_list_params, + message_create_params, + message_update_params, + message_list_paginated_params, +) from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property @@ -30,6 +35,7 @@ from ...types.task_message import TaskMessage from ...types.message_list_response import MessageListResponse from ...types.task_message_content_param import TaskMessageContentParam +from ...types.message_list_paginated_response import MessageListPaginatedResponse __all__ = ["MessagesResource", "AsyncMessagesResource"] @@ -180,7 +186,10 @@ def list( self, *, task_id: str, - limit: Optional[int] | Omit = omit, + limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, + page_number: int | 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, @@ -189,7 +198,10 @@ def list( timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ - List Messages + List messages for a task with offset-based pagination. + + For cursor-based pagination with infinite scroll support, use + /messages/paginated. Args: task_id: The task ID @@ -213,6 +225,9 @@ def list( { "task_id": task_id, "limit": limit, + "order_by": order_by, + "order_direction": order_direction, + "page_number": page_number, }, message_list_params.MessageListParams, ), @@ -220,6 +235,70 @@ def list( cast_to=MessageListResponse, ) + def list_paginated( + self, + *, + task_id: str, + cursor: Optional[str] | Omit = omit, + direction: Literal["older", "newer"] | Omit = omit, + limit: int | 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, + ) -> MessageListPaginatedResponse: + """ + List messages for a task with cursor-based pagination. + + This endpoint is designed for infinite scroll UIs where new messages may arrive + while paginating through older ones. + + Args: task_id: The task ID to filter messages by limit: Maximum number of + messages to return (default: 50) cursor: Opaque cursor string for pagination. + Pass the `next_cursor` from a previous response to get the next page. direction: + Pagination direction - "older" to get older messages (default), "newer" to get + newer messages. + + Returns: PaginatedMessagesResponse with: - data: List of messages (newest first + when direction="older") - next_cursor: Cursor for fetching the next page (null + if no more pages) - has_more: Whether there are more messages to fetch + + Example: First request: GET /messages/paginated?task_id=xxx&limit=50 Next page: + GET /messages/paginated?task_id=xxx&limit=50&cursor= + + Args: + task_id: The task ID + + 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 + """ + return self._get( + "/messages/paginated", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "task_id": task_id, + "cursor": cursor, + "direction": direction, + "limit": limit, + }, + message_list_paginated_params.MessageListPaginatedParams, + ), + ), + cast_to=MessageListPaginatedResponse, + ) + class AsyncMessagesResource(AsyncAPIResource): @cached_property @@ -367,7 +446,10 @@ async def list( self, *, task_id: str, - limit: Optional[int] | Omit = omit, + limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, + page_number: int | 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, @@ -376,7 +458,10 @@ async def list( timeout: float | httpx.Timeout | None | NotGiven = not_given, ) -> MessageListResponse: """ - List Messages + List messages for a task with offset-based pagination. + + For cursor-based pagination with infinite scroll support, use + /messages/paginated. Args: task_id: The task ID @@ -400,6 +485,9 @@ async def list( { "task_id": task_id, "limit": limit, + "order_by": order_by, + "order_direction": order_direction, + "page_number": page_number, }, message_list_params.MessageListParams, ), @@ -407,6 +495,70 @@ async def list( cast_to=MessageListResponse, ) + async def list_paginated( + self, + *, + task_id: str, + cursor: Optional[str] | Omit = omit, + direction: Literal["older", "newer"] | Omit = omit, + limit: int | 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, + ) -> MessageListPaginatedResponse: + """ + List messages for a task with cursor-based pagination. + + This endpoint is designed for infinite scroll UIs where new messages may arrive + while paginating through older ones. + + Args: task_id: The task ID to filter messages by limit: Maximum number of + messages to return (default: 50) cursor: Opaque cursor string for pagination. + Pass the `next_cursor` from a previous response to get the next page. direction: + Pagination direction - "older" to get older messages (default), "newer" to get + newer messages. + + Returns: PaginatedMessagesResponse with: - data: List of messages (newest first + when direction="older") - next_cursor: Cursor for fetching the next page (null + if no more pages) - has_more: Whether there are more messages to fetch + + Example: First request: GET /messages/paginated?task_id=xxx&limit=50 Next page: + GET /messages/paginated?task_id=xxx&limit=50&cursor= + + Args: + task_id: The task ID + + 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 + """ + return await self._get( + "/messages/paginated", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "task_id": task_id, + "cursor": cursor, + "direction": direction, + "limit": limit, + }, + message_list_paginated_params.MessageListPaginatedParams, + ), + ), + cast_to=MessageListPaginatedResponse, + ) + class MessagesResourceWithRawResponse: def __init__(self, messages: MessagesResource) -> None: @@ -424,6 +576,9 @@ def __init__(self, messages: MessagesResource) -> None: self.list = to_raw_response_wrapper( messages.list, ) + self.list_paginated = to_raw_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> BatchResourceWithRawResponse: @@ -446,6 +601,9 @@ def __init__(self, messages: AsyncMessagesResource) -> None: self.list = async_to_raw_response_wrapper( messages.list, ) + self.list_paginated = async_to_raw_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> AsyncBatchResourceWithRawResponse: @@ -468,6 +626,9 @@ def __init__(self, messages: MessagesResource) -> None: self.list = to_streamed_response_wrapper( messages.list, ) + self.list_paginated = to_streamed_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> BatchResourceWithStreamingResponse: @@ -490,6 +651,9 @@ def __init__(self, messages: AsyncMessagesResource) -> None: self.list = async_to_streamed_response_wrapper( messages.list, ) + self.list_paginated = async_to_streamed_response_wrapper( + messages.list_paginated, + ) @cached_property def batch(self) -> AsyncBatchResourceWithStreamingResponse: diff --git a/src/agentex/resources/spans.py b/src/agentex/resources/spans.py index 068384c3..589c2ac6 100644 --- a/src/agentex/resources/spans.py +++ b/src/agentex/resources/spans.py @@ -222,6 +222,10 @@ def update( def list( self, *, + limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, + page_number: int | Omit = omit, trace_id: Optional[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. @@ -249,7 +253,16 @@ def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=maybe_transform({"trace_id": trace_id}, span_list_params.SpanListParams), + query=maybe_transform( + { + "limit": limit, + "order_by": order_by, + "order_direction": order_direction, + "page_number": page_number, + "trace_id": trace_id, + }, + span_list_params.SpanListParams, + ), ), cast_to=SpanListResponse, ) @@ -452,6 +465,10 @@ async def update( async def list( self, *, + limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, + page_number: int | Omit = omit, trace_id: Optional[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. @@ -479,7 +496,16 @@ async def list( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - query=await async_maybe_transform({"trace_id": trace_id}, span_list_params.SpanListParams), + query=await async_maybe_transform( + { + "limit": limit, + "order_by": order_by, + "order_direction": order_direction, + "page_number": page_number, + "trace_id": trace_id, + }, + span_list_params.SpanListParams, + ), ), cast_to=SpanListResponse, ) diff --git a/src/agentex/resources/states.py b/src/agentex/resources/states.py index 6196e4e4..a8f3d085 100644 --- a/src/agentex/resources/states.py +++ b/src/agentex/resources/states.py @@ -166,6 +166,10 @@ def list( self, *, agent_id: Optional[str] | Omit = omit, + limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, + page_number: int | Omit = omit, task_id: Optional[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. @@ -180,6 +184,14 @@ def list( Args: agent_id: Agent ID + limit: Limit + + order_by: Field to order by + + order_direction: Order direction (asc or desc) + + page_number: Page number + task_id: Task ID extra_headers: Send extra headers @@ -200,6 +212,10 @@ def list( query=maybe_transform( { "agent_id": agent_id, + "limit": limit, + "order_by": order_by, + "order_direction": order_direction, + "page_number": page_number, "task_id": task_id, }, state_list_params.StateListParams, @@ -384,6 +400,10 @@ async def list( self, *, agent_id: Optional[str] | Omit = omit, + limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, + page_number: int | Omit = omit, task_id: Optional[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. @@ -398,6 +418,14 @@ async def list( Args: agent_id: Agent ID + limit: Limit + + order_by: Field to order by + + order_direction: Order direction (asc or desc) + + page_number: Page number + task_id: Task ID extra_headers: Send extra headers @@ -418,6 +446,10 @@ async def list( query=await async_maybe_transform( { "agent_id": agent_id, + "limit": limit, + "order_by": order_by, + "order_direction": order_direction, + "page_number": page_number, "task_id": task_id, }, state_list_params.StateListParams, diff --git a/src/agentex/resources/tasks.py b/src/agentex/resources/tasks.py index 94e7c866..1bf41b7b 100644 --- a/src/agentex/resources/tasks.py +++ b/src/agentex/resources/tasks.py @@ -2,11 +2,12 @@ from __future__ import annotations -from typing import Optional +from typing import List, Optional +from typing_extensions import Literal import httpx -from ..types import task_list_params +from ..types import task_list_params, task_retrieve_params, task_retrieve_by_name_params from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property @@ -18,10 +19,11 @@ async_to_streamed_response_wrapper, ) from .._streaming import Stream, AsyncStream -from ..types.task import Task from .._base_client import make_request_options from ..types.task_list_response import TaskListResponse from ..types.shared.delete_response import DeleteResponse +from ..types.task_retrieve_response import TaskRetrieveResponse +from ..types.task_retrieve_by_name_response import TaskRetrieveByNameResponse __all__ = ["TasksResource", "AsyncTasksResource"] @@ -50,13 +52,14 @@ def retrieve( self, task_id: str, *, + relationships: List[Literal["agents"]] | 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, - ) -> Task: + ) -> TaskRetrieveResponse: """ Get a task by its unique ID. @@ -74,9 +77,13 @@ def retrieve( return self._get( f"/tasks/{task_id}", options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform({"relationships": relationships}, task_retrieve_params.TaskRetrieveParams), ), - cast_to=Task, + cast_to=TaskRetrieveResponse, ) def list( @@ -84,6 +91,11 @@ def list( *, agent_id: Optional[str] | Omit = omit, agent_name: Optional[str] | Omit = omit, + limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, + page_number: int | Omit = omit, + relationships: List[Literal["agents"]] | 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, @@ -114,6 +126,11 @@ def list( { "agent_id": agent_id, "agent_name": agent_name, + "limit": limit, + "order_by": order_by, + "order_direction": order_direction, + "page_number": page_number, + "relationships": relationships, }, task_list_params.TaskListParams, ), @@ -191,13 +208,14 @@ def retrieve_by_name( self, task_name: str, *, + relationships: List[Literal["agents"]] | 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, - ) -> Task: + ) -> TaskRetrieveByNameResponse: """ Get a task by its unique name. @@ -215,9 +233,15 @@ def retrieve_by_name( return self._get( f"/tasks/name/{task_name}", options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + {"relationships": relationships}, task_retrieve_by_name_params.TaskRetrieveByNameParams + ), ), - cast_to=Task, + cast_to=TaskRetrieveByNameResponse, ) def stream_events( @@ -315,13 +339,14 @@ async def retrieve( self, task_id: str, *, + relationships: List[Literal["agents"]] | 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, - ) -> Task: + ) -> TaskRetrieveResponse: """ Get a task by its unique ID. @@ -339,9 +364,15 @@ async def retrieve( return await self._get( f"/tasks/{task_id}", options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + {"relationships": relationships}, task_retrieve_params.TaskRetrieveParams + ), ), - cast_to=Task, + cast_to=TaskRetrieveResponse, ) async def list( @@ -349,6 +380,11 @@ async def list( *, agent_id: Optional[str] | Omit = omit, agent_name: Optional[str] | Omit = omit, + limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, + page_number: int | Omit = omit, + relationships: List[Literal["agents"]] | 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, @@ -379,6 +415,11 @@ async def list( { "agent_id": agent_id, "agent_name": agent_name, + "limit": limit, + "order_by": order_by, + "order_direction": order_direction, + "page_number": page_number, + "relationships": relationships, }, task_list_params.TaskListParams, ), @@ -456,13 +497,14 @@ async def retrieve_by_name( self, task_name: str, *, + relationships: List[Literal["agents"]] | 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, - ) -> Task: + ) -> TaskRetrieveByNameResponse: """ Get a task by its unique name. @@ -480,9 +522,15 @@ async def retrieve_by_name( return await self._get( f"/tasks/name/{task_name}", options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + {"relationships": relationships}, task_retrieve_by_name_params.TaskRetrieveByNameParams + ), ), - cast_to=Task, + cast_to=TaskRetrieveByNameResponse, ) async def stream_events( diff --git a/src/agentex/resources/tracker.py b/src/agentex/resources/tracker.py index 089e6a62..15906b3f 100644 --- a/src/agentex/resources/tracker.py +++ b/src/agentex/resources/tracker.py @@ -131,6 +131,10 @@ def list( self, *, agent_id: Optional[str] | Omit = omit, + limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, + page_number: int | Omit = omit, task_id: Optional[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. @@ -145,6 +149,14 @@ def list( Args: agent_id: Agent ID + limit: Limit + + order_by: Field to order by + + order_direction: Order direction (asc or desc) + + page_number: Page number + task_id: Task ID extra_headers: Send extra headers @@ -165,6 +177,10 @@ def list( query=maybe_transform( { "agent_id": agent_id, + "limit": limit, + "order_by": order_by, + "order_direction": order_direction, + "page_number": page_number, "task_id": task_id, }, tracker_list_params.TrackerListParams, @@ -281,6 +297,10 @@ async def list( self, *, agent_id: Optional[str] | Omit = omit, + limit: int | Omit = omit, + order_by: Optional[str] | Omit = omit, + order_direction: str | Omit = omit, + page_number: int | Omit = omit, task_id: Optional[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. @@ -295,6 +315,14 @@ async def list( Args: agent_id: Agent ID + limit: Limit + + order_by: Field to order by + + order_direction: Order direction (asc or desc) + + page_number: Page number + task_id: Task ID extra_headers: Send extra headers @@ -315,6 +343,10 @@ async def list( query=await async_maybe_transform( { "agent_id": agent_id, + "limit": limit, + "order_by": order_by, + "order_direction": order_direction, + "page_number": page_number, "task_id": task_id, }, tracker_list_params.TrackerListParams, diff --git a/src/agentex/types/__init__.py b/src/agentex/types/__init__.py index 0445dfad..8628bd3c 100644 --- a/src/agentex/types/__init__.py +++ b/src/agentex/types/__init__.py @@ -45,6 +45,7 @@ from .tool_response_delta import ToolResponseDelta as ToolResponseDelta from .tracker_list_params import TrackerListParams as TrackerListParams from .task_message_content import TaskMessageContent as TaskMessageContent +from .task_retrieve_params import TaskRetrieveParams as TaskRetrieveParams from .tool_request_content import ToolRequestContent as ToolRequestContent from .message_create_params import MessageCreateParams as MessageCreateParams from .message_list_response import MessageListResponse as MessageListResponse @@ -52,6 +53,7 @@ from .tool_response_content import ToolResponseContent as ToolResponseContent from .tracker_list_response import TrackerListResponse as TrackerListResponse from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams +from .task_retrieve_response import TaskRetrieveResponse as TaskRetrieveResponse from .reasoning_content_delta import ReasoningContentDelta as ReasoningContentDelta from .reasoning_content_param import ReasoningContentParam as ReasoningContentParam from .reasoning_summary_delta import ReasoningSummaryDelta as ReasoningSummaryDelta @@ -59,3 +61,7 @@ from .task_message_content_param import TaskMessageContentParam as TaskMessageContentParam from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam +from .task_retrieve_by_name_params import TaskRetrieveByNameParams as TaskRetrieveByNameParams +from .message_list_paginated_params import MessageListPaginatedParams as MessageListPaginatedParams +from .task_retrieve_by_name_response import TaskRetrieveByNameResponse as TaskRetrieveByNameResponse +from .message_list_paginated_response import MessageListPaginatedResponse as MessageListPaginatedResponse diff --git a/src/agentex/types/acp_type.py b/src/agentex/types/acp_type.py index ec86ddf5..8b70a292 100644 --- a/src/agentex/types/acp_type.py +++ b/src/agentex/types/acp_type.py @@ -4,4 +4,4 @@ __all__ = ["AcpType"] -AcpType: TypeAlias = Literal["sync", "agentic"] +AcpType: TypeAlias = Literal["sync", "async", "agentic"] diff --git a/src/agentex/types/agent.py b/src/agentex/types/agent.py index 731332ab..7828822c 100644 --- a/src/agentex/types/agent.py +++ b/src/agentex/types/agent.py @@ -15,7 +15,7 @@ class Agent(BaseModel): """The unique identifier of the agent.""" acp_type: AcpType - """The type of the ACP Server (Either sync or agentic)""" + """The type of the ACP Server (Either sync or async)""" created_at: datetime """The timestamp when the agent was created""" @@ -29,13 +29,16 @@ class Agent(BaseModel): updated_at: datetime """The timestamp when the agent was last updated""" + agent_input_type: Optional[Literal["text", "json"]] = None + """The type of input the agent expects.""" + registered_at: Optional[datetime] = None """The timestamp when the agent was last registered""" registration_metadata: Optional[Dict[str, object]] = None """The metadata for the agent's registration.""" - status: Optional[Literal["Ready", "Failed", "Unknown", "Deleted"]] = None + status: Optional[Literal["Ready", "Failed", "Unknown", "Deleted", "Unhealthy"]] = None """The status of the action, indicating if it's building, ready, failed, etc.""" status_reason: Optional[str] = None diff --git a/src/agentex/types/agent_list_params.py b/src/agentex/types/agent_list_params.py index b432174a..084fdfae 100644 --- a/src/agentex/types/agent_list_params.py +++ b/src/agentex/types/agent_list_params.py @@ -9,5 +9,17 @@ class AgentListParams(TypedDict, total=False): + limit: int + """Limit""" + + order_by: Optional[str] + """Field to order by""" + + order_direction: str + """Order direction (asc or desc)""" + + page_number: int + """Page number""" + task_id: Optional[str] """Task ID""" diff --git a/src/agentex/types/message_list_paginated_params.py b/src/agentex/types/message_list_paginated_params.py new file mode 100644 index 00000000..6dfe1e7e --- /dev/null +++ b/src/agentex/types/message_list_paginated_params.py @@ -0,0 +1,19 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Literal, Required, TypedDict + +__all__ = ["MessageListPaginatedParams"] + + +class MessageListPaginatedParams(TypedDict, total=False): + task_id: Required[str] + """The task ID""" + + cursor: Optional[str] + + direction: Literal["older", "newer"] + + limit: int diff --git a/src/agentex/types/message_list_paginated_response.py b/src/agentex/types/message_list_paginated_response.py new file mode 100644 index 00000000..40af0b4a --- /dev/null +++ b/src/agentex/types/message_list_paginated_response.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from .._models import BaseModel +from .task_message import TaskMessage + +__all__ = ["MessageListPaginatedResponse"] + + +class MessageListPaginatedResponse(BaseModel): + """Response with cursor pagination metadata.""" + + data: List[TaskMessage] + """List of messages""" + + has_more: Optional[bool] = None + """Whether there are more messages to fetch""" + + next_cursor: Optional[str] = None + """Cursor for fetching the next page of older messages""" diff --git a/src/agentex/types/message_list_params.py b/src/agentex/types/message_list_params.py index 4911bfa9..87027eed 100644 --- a/src/agentex/types/message_list_params.py +++ b/src/agentex/types/message_list_params.py @@ -12,4 +12,10 @@ class MessageListParams(TypedDict, total=False): task_id: Required[str] """The task ID""" - limit: Optional[int] + limit: int + + order_by: Optional[str] + + order_direction: str + + page_number: int diff --git a/src/agentex/types/span_list_params.py b/src/agentex/types/span_list_params.py index 35218965..40d4d651 100644 --- a/src/agentex/types/span_list_params.py +++ b/src/agentex/types/span_list_params.py @@ -9,4 +9,12 @@ class SpanListParams(TypedDict, total=False): + limit: int + + order_by: Optional[str] + + order_direction: str + + page_number: int + trace_id: Optional[str] diff --git a/src/agentex/types/state_list_params.py b/src/agentex/types/state_list_params.py index 6034d345..9cb7d3dc 100644 --- a/src/agentex/types/state_list_params.py +++ b/src/agentex/types/state_list_params.py @@ -12,5 +12,17 @@ class StateListParams(TypedDict, total=False): agent_id: Optional[str] """Agent ID""" + limit: int + """Limit""" + + order_by: Optional[str] + """Field to order by""" + + order_direction: str + """Order direction (asc or desc)""" + + page_number: int + """Page number""" + task_id: Optional[str] """Task ID""" diff --git a/src/agentex/types/task_list_params.py b/src/agentex/types/task_list_params.py index f8bc3364..e41bf821 100644 --- a/src/agentex/types/task_list_params.py +++ b/src/agentex/types/task_list_params.py @@ -2,8 +2,8 @@ from __future__ import annotations -from typing import Optional -from typing_extensions import TypedDict +from typing import List, Optional +from typing_extensions import Literal, TypedDict __all__ = ["TaskListParams"] @@ -12,3 +12,13 @@ class TaskListParams(TypedDict, total=False): agent_id: Optional[str] agent_name: Optional[str] + + limit: int + + order_by: Optional[str] + + order_direction: str + + page_number: int + + relationships: List[Literal["agents"]] diff --git a/src/agentex/types/task_list_response.py b/src/agentex/types/task_list_response.py index c9607e60..85f87c0e 100644 --- a/src/agentex/types/task_list_response.py +++ b/src/agentex/types/task_list_response.py @@ -1,10 +1,35 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import List -from typing_extensions import TypeAlias +from typing import Dict, List, Optional +from datetime import datetime +from typing_extensions import Literal, TypeAlias -from .task import Task +from .agent import Agent +from .._models import BaseModel -__all__ = ["TaskListResponse"] +__all__ = ["TaskListResponse", "TaskListResponseItem"] -TaskListResponse: TypeAlias = List[Task] + +class TaskListResponseItem(BaseModel): + """Task response model with optional related data based on relationships""" + + id: str + + agents: Optional[List[Agent]] = None + + created_at: Optional[datetime] = None + + name: Optional[str] = None + + params: Optional[Dict[str, object]] = None + + status: Optional[Literal["CANCELED", "COMPLETED", "FAILED", "RUNNING", "TERMINATED", "TIMED_OUT", "DELETED"]] = None + + status_reason: Optional[str] = None + + task_metadata: Optional[Dict[str, object]] = None + + updated_at: Optional[datetime] = None + + +TaskListResponse: TypeAlias = List[TaskListResponseItem] diff --git a/src/agentex/types/task_retrieve_by_name_params.py b/src/agentex/types/task_retrieve_by_name_params.py new file mode 100644 index 00000000..98d03982 --- /dev/null +++ b/src/agentex/types/task_retrieve_by_name_params.py @@ -0,0 +1,12 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List +from typing_extensions import Literal, TypedDict + +__all__ = ["TaskRetrieveByNameParams"] + + +class TaskRetrieveByNameParams(TypedDict, total=False): + relationships: List[Literal["agents"]] diff --git a/src/agentex/types/task_retrieve_by_name_response.py b/src/agentex/types/task_retrieve_by_name_response.py new file mode 100644 index 00000000..1ffc6819 --- /dev/null +++ b/src/agentex/types/task_retrieve_by_name_response.py @@ -0,0 +1,32 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict, List, Optional +from datetime import datetime +from typing_extensions import Literal + +from .agent import Agent +from .._models import BaseModel + +__all__ = ["TaskRetrieveByNameResponse"] + + +class TaskRetrieveByNameResponse(BaseModel): + """Task response model with optional related data based on relationships""" + + id: str + + agents: Optional[List[Agent]] = None + + created_at: Optional[datetime] = None + + name: Optional[str] = None + + params: Optional[Dict[str, object]] = None + + status: Optional[Literal["CANCELED", "COMPLETED", "FAILED", "RUNNING", "TERMINATED", "TIMED_OUT", "DELETED"]] = None + + status_reason: Optional[str] = None + + task_metadata: Optional[Dict[str, object]] = None + + updated_at: Optional[datetime] = None diff --git a/src/agentex/types/task_retrieve_params.py b/src/agentex/types/task_retrieve_params.py new file mode 100644 index 00000000..61748a1b --- /dev/null +++ b/src/agentex/types/task_retrieve_params.py @@ -0,0 +1,12 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List +from typing_extensions import Literal, TypedDict + +__all__ = ["TaskRetrieveParams"] + + +class TaskRetrieveParams(TypedDict, total=False): + relationships: List[Literal["agents"]] diff --git a/src/agentex/types/task_retrieve_response.py b/src/agentex/types/task_retrieve_response.py new file mode 100644 index 00000000..5f262946 --- /dev/null +++ b/src/agentex/types/task_retrieve_response.py @@ -0,0 +1,32 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict, List, Optional +from datetime import datetime +from typing_extensions import Literal + +from .agent import Agent +from .._models import BaseModel + +__all__ = ["TaskRetrieveResponse"] + + +class TaskRetrieveResponse(BaseModel): + """Task response model with optional related data based on relationships""" + + id: str + + agents: Optional[List[Agent]] = None + + created_at: Optional[datetime] = None + + name: Optional[str] = None + + params: Optional[Dict[str, object]] = None + + status: Optional[Literal["CANCELED", "COMPLETED", "FAILED", "RUNNING", "TERMINATED", "TIMED_OUT", "DELETED"]] = None + + status_reason: Optional[str] = None + + task_metadata: Optional[Dict[str, object]] = None + + updated_at: Optional[datetime] = None diff --git a/src/agentex/types/tracker_list_params.py b/src/agentex/types/tracker_list_params.py index 47b4da7b..57234f4a 100644 --- a/src/agentex/types/tracker_list_params.py +++ b/src/agentex/types/tracker_list_params.py @@ -12,5 +12,17 @@ class TrackerListParams(TypedDict, total=False): agent_id: Optional[str] """Agent ID""" + limit: int + """Limit""" + + order_by: Optional[str] + """Field to order by""" + + order_direction: str + """Order direction (asc or desc)""" + + page_number: int + """Page number""" + task_id: Optional[str] """Task ID""" diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index 7ef11072..340238ba 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -74,6 +74,10 @@ def test_method_list(self, client: Agentex) -> None: @parametrize def test_method_list_with_all_params(self, client: Agentex) -> None: agent = client.agents.list( + limit=1, + order_by="order_by", + order_direction="order_direction", + page_number=1, task_id="task_id", ) assert_matches_type(AgentListResponse, agent, path=["response"]) @@ -414,6 +418,10 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: @parametrize async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: agent = await async_client.agents.list( + limit=1, + order_by="order_by", + order_direction="order_direction", + page_number=1, task_id="task_id", ) assert_matches_type(AgentListResponse, agent, path=["response"]) diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py index 457d3e24..4b234334 100644 --- a/tests/api_resources/test_messages.py +++ b/tests/api_resources/test_messages.py @@ -12,6 +12,7 @@ from agentex.types import ( TaskMessage, MessageListResponse, + MessageListPaginatedResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -240,6 +241,9 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: message = client.messages.list( task_id="task_id", limit=0, + order_by="order_by", + order_direction="order_direction", + page_number=0, ) assert_matches_type(MessageListResponse, message, path=["response"]) @@ -269,6 +273,51 @@ def test_streaming_response_list(self, client: Agentex) -> None: assert cast(Any, response.is_closed) is True + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_list_paginated(self, client: Agentex) -> None: + message = client.messages.list_paginated( + task_id="task_id", + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_list_paginated_with_all_params(self, client: Agentex) -> None: + message = client.messages.list_paginated( + task_id="task_id", + cursor="cursor", + direction="older", + limit=0, + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_raw_response_list_paginated(self, client: Agentex) -> None: + response = client.messages.with_raw_response.list_paginated( + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_streaming_response_list_paginated(self, client: Agentex) -> None: + with client.messages.with_streaming_response.list_paginated( + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + assert cast(Any, response.is_closed) is True + class TestAsyncMessages: parametrize = pytest.mark.parametrize( @@ -495,6 +544,9 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> message = await async_client.messages.list( task_id="task_id", limit=0, + order_by="order_by", + order_direction="order_direction", + page_number=0, ) assert_matches_type(MessageListResponse, message, path=["response"]) @@ -523,3 +575,48 @@ async def test_streaming_response_list(self, async_client: AsyncAgentex) -> None assert_matches_type(MessageListResponse, message, path=["response"]) assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_list_paginated(self, async_client: AsyncAgentex) -> None: + message = await async_client.messages.list_paginated( + task_id="task_id", + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_list_paginated_with_all_params(self, async_client: AsyncAgentex) -> None: + message = await async_client.messages.list_paginated( + task_id="task_id", + cursor="cursor", + direction="older", + limit=0, + ) + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_raw_response_list_paginated(self, async_client: AsyncAgentex) -> None: + response = await async_client.messages.with_raw_response.list_paginated( + task_id="task_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + message = await response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_streaming_response_list_paginated(self, async_client: AsyncAgentex) -> None: + async with async_client.messages.with_streaming_response.list_paginated( + task_id="task_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + message = await response.parse() + assert_matches_type(MessageListPaginatedResponse, message, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_spans.py b/tests/api_resources/test_spans.py index b9c9b168..ef991d4e 100644 --- a/tests/api_resources/test_spans.py +++ b/tests/api_resources/test_spans.py @@ -184,6 +184,10 @@ def test_method_list(self, client: Agentex) -> None: @parametrize def test_method_list_with_all_params(self, client: Agentex) -> None: span = client.spans.list( + limit=0, + order_by="order_by", + order_direction="order_direction", + page_number=0, trace_id="trace_id", ) assert_matches_type(SpanListResponse, span, path=["response"]) @@ -382,6 +386,10 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: @parametrize async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: span = await async_client.spans.list( + limit=0, + order_by="order_by", + order_direction="order_direction", + page_number=0, trace_id="trace_id", ) assert_matches_type(SpanListResponse, span, path=["response"]) diff --git a/tests/api_resources/test_states.py b/tests/api_resources/test_states.py index b23ff49a..c8cfd84c 100644 --- a/tests/api_resources/test_states.py +++ b/tests/api_resources/test_states.py @@ -164,6 +164,10 @@ def test_method_list(self, client: Agentex) -> None: def test_method_list_with_all_params(self, client: Agentex) -> None: state = client.states.list( agent_id="agent_id", + limit=1, + order_by="order_by", + order_direction="order_direction", + page_number=1, task_id="task_id", ) assert_matches_type(StateListResponse, state, path=["response"]) @@ -385,6 +389,10 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: state = await async_client.states.list( agent_id="agent_id", + limit=1, + order_by="order_by", + order_direction="order_direction", + page_number=1, task_id="task_id", ) assert_matches_type(StateListResponse, state, path=["response"]) diff --git a/tests/api_resources/test_tasks.py b/tests/api_resources/test_tasks.py index ac858a80..6c2f2c54 100644 --- a/tests/api_resources/test_tasks.py +++ b/tests/api_resources/test_tasks.py @@ -9,7 +9,11 @@ from agentex import Agentex, AsyncAgentex from tests.utils import assert_matches_type -from agentex.types import Task, TaskListResponse +from agentex.types import ( + TaskListResponse, + TaskRetrieveResponse, + TaskRetrieveByNameResponse, +) from agentex.types.shared import DeleteResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -22,33 +26,42 @@ class TestTasks: @parametrize def test_method_retrieve(self, client: Agentex) -> None: task = client.tasks.retrieve( - "task_id", + task_id="task_id", ) - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_retrieve_with_all_params(self, client: Agentex) -> None: + task = client.tasks.retrieve( + task_id="task_id", + relationships=["agents"], + ) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve(self, client: Agentex) -> None: response = client.tasks.with_raw_response.retrieve( - "task_id", + task_id="task_id", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: Agentex) -> None: with client.tasks.with_streaming_response.retrieve( - "task_id", + task_id="task_id", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -57,7 +70,7 @@ def test_streaming_response_retrieve(self, client: Agentex) -> None: def test_path_params_retrieve(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): client.tasks.with_raw_response.retrieve( - "", + task_id="", ) @pytest.mark.skip(reason="Prism tests are disabled") @@ -72,6 +85,11 @@ def test_method_list_with_all_params(self, client: Agentex) -> None: task = client.tasks.list( agent_id="agent_id", agent_name="agent_name", + limit=0, + order_by="order_by", + order_direction="order_direction", + page_number=0, + relationships=["agents"], ) assert_matches_type(TaskListResponse, task, path=["response"]) @@ -185,33 +203,42 @@ def test_path_params_delete_by_name(self, client: Agentex) -> None: @parametrize def test_method_retrieve_by_name(self, client: Agentex) -> None: task = client.tasks.retrieve_by_name( - "task_name", + task_name="task_name", ) - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_retrieve_by_name_with_all_params(self, client: Agentex) -> None: + task = client.tasks.retrieve_by_name( + task_name="task_name", + relationships=["agents"], + ) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve_by_name(self, client: Agentex) -> None: response = client.tasks.with_raw_response.retrieve_by_name( - "task_name", + task_name="task_name", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve_by_name(self, client: Agentex) -> None: with client.tasks.with_streaming_response.retrieve_by_name( - "task_name", + task_name="task_name", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -220,7 +247,7 @@ def test_streaming_response_retrieve_by_name(self, client: Agentex) -> None: def test_path_params_retrieve_by_name(self, client: Agentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): client.tasks.with_raw_response.retrieve_by_name( - "", + task_name="", ) @pytest.mark.skip(reason="Prism tests are disabled") @@ -315,33 +342,42 @@ class TestAsyncTasks: @parametrize async def test_method_retrieve(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.retrieve( - "task_id", + task_id="task_id", ) - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_retrieve_with_all_params(self, async_client: AsyncAgentex) -> None: + task = await async_client.tasks.retrieve( + task_id="task_id", + relationships=["agents"], + ) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.retrieve( - "task_id", + task_id="task_id", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.retrieve( - "task_id", + task_id="task_id", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -350,7 +386,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncAgentex) -> async def test_path_params_retrieve(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_id` but received ''"): await async_client.tasks.with_raw_response.retrieve( - "", + task_id="", ) @pytest.mark.skip(reason="Prism tests are disabled") @@ -365,6 +401,11 @@ async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> task = await async_client.tasks.list( agent_id="agent_id", agent_name="agent_name", + limit=0, + order_by="order_by", + order_direction="order_direction", + page_number=0, + relationships=["agents"], ) assert_matches_type(TaskListResponse, task, path=["response"]) @@ -478,33 +519,42 @@ async def test_path_params_delete_by_name(self, async_client: AsyncAgentex) -> N @parametrize async def test_method_retrieve_by_name(self, async_client: AsyncAgentex) -> None: task = await async_client.tasks.retrieve_by_name( - "task_name", + task_name="task_name", ) - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_retrieve_by_name_with_all_params(self, async_client: AsyncAgentex) -> None: + task = await async_client.tasks.retrieve_by_name( + task_name="task_name", + relationships=["agents"], + ) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve_by_name(self, async_client: AsyncAgentex) -> None: response = await async_client.tasks.with_raw_response.retrieve_by_name( - "task_name", + task_name="task_name", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve_by_name(self, async_client: AsyncAgentex) -> None: async with async_client.tasks.with_streaming_response.retrieve_by_name( - "task_name", + task_name="task_name", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" task = await response.parse() - assert_matches_type(Task, task, path=["response"]) + assert_matches_type(TaskRetrieveByNameResponse, task, path=["response"]) assert cast(Any, response.is_closed) is True @@ -513,7 +563,7 @@ async def test_streaming_response_retrieve_by_name(self, async_client: AsyncAgen async def test_path_params_retrieve_by_name(self, async_client: AsyncAgentex) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `task_name` but received ''"): await async_client.tasks.with_raw_response.retrieve_by_name( - "", + task_name="", ) @pytest.mark.skip(reason="Prism tests are disabled") diff --git a/tests/api_resources/test_tracker.py b/tests/api_resources/test_tracker.py index 431508c3..5ea656f6 100644 --- a/tests/api_resources/test_tracker.py +++ b/tests/api_resources/test_tracker.py @@ -123,6 +123,10 @@ def test_method_list(self, client: Agentex) -> None: def test_method_list_with_all_params(self, client: Agentex) -> None: tracker = client.tracker.list( agent_id="agent_id", + limit=1, + order_by="order_by", + order_direction="order_direction", + page_number=1, task_id="task_id", ) assert_matches_type(TrackerListResponse, tracker, path=["response"]) @@ -261,6 +265,10 @@ async def test_method_list(self, async_client: AsyncAgentex) -> None: async def test_method_list_with_all_params(self, async_client: AsyncAgentex) -> None: tracker = await async_client.tracker.list( agent_id="agent_id", + limit=1, + order_by="order_by", + order_direction="order_direction", + page_number=1, task_id="task_id", ) assert_matches_type(TrackerListResponse, tracker, path=["response"]) From c378f82048a00492c023e7cbe6f5544ab339f443 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 15 Dec 2025 19:22:43 +0000 Subject: [PATCH 1107/1108] chore(internal): add missing files argument to base client --- src/agentex/_base_client.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/agentex/_base_client.py b/src/agentex/_base_client.py index 108a8a52..2d022cda 100644 --- a/src/agentex/_base_client.py +++ b/src/agentex/_base_client.py @@ -1247,9 +1247,12 @@ def patch( *, cast_to: Type[ResponseT], body: Body | None = None, + files: RequestFiles | None = None, options: RequestOptions = {}, ) -> ResponseT: - opts = FinalRequestOptions.construct(method="patch", url=path, json_data=body, **options) + opts = FinalRequestOptions.construct( + method="patch", url=path, json_data=body, files=to_httpx_files(files), **options + ) return self.request(cast_to, opts) def put( @@ -1767,9 +1770,12 @@ async def patch( *, cast_to: Type[ResponseT], body: Body | None = None, + files: RequestFiles | None = None, options: RequestOptions = {}, ) -> ResponseT: - opts = FinalRequestOptions.construct(method="patch", url=path, json_data=body, **options) + opts = FinalRequestOptions.construct( + method="patch", url=path, json_data=body, files=to_httpx_files(files), **options + ) return await self.request(cast_to, opts) async def put( From 16df08d070178b0cdb76ffc205152c467a0e3b6c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Dec 2025 17:24:30 +0000 Subject: [PATCH 1108/1108] chore: speedup initial import --- src/agentex/_client.py | 359 +++++++++++++++++++++++++++++++++-------- 1 file changed, 290 insertions(+), 69 deletions(-) diff --git a/src/agentex/_client.py b/src/agentex/_client.py index a87f6cbf..0cb9fc45 100644 --- a/src/agentex/_client.py +++ b/src/agentex/_client.py @@ -3,7 +3,7 @@ from __future__ import annotations import os -from typing import Any, Dict, Mapping, cast +from typing import TYPE_CHECKING, Any, Dict, Mapping, cast from typing_extensions import Self, Literal, override import httpx @@ -20,8 +20,8 @@ not_given, ) from ._utils import is_given, get_async_library +from ._compat import cached_property from ._version import __version__ -from .resources import spans, tasks, agents, events, states, tracker from ._streaming import Stream as Stream, AsyncStream as AsyncStream from ._exceptions import APIStatusError from ._base_client import ( @@ -29,7 +29,16 @@ SyncAPIClient, AsyncAPIClient, ) -from .resources.messages import messages + +if TYPE_CHECKING: + from .resources import spans, tasks, agents, events, states, tracker, messages + from .resources.spans import SpansResource, AsyncSpansResource + from .resources.tasks import TasksResource, AsyncTasksResource + from .resources.agents import AgentsResource, AsyncAgentsResource + from .resources.events import EventsResource, AsyncEventsResource + from .resources.states import StatesResource, AsyncStatesResource + from .resources.tracker import TrackerResource, AsyncTrackerResource + from .resources.messages.messages import MessagesResource, AsyncMessagesResource __all__ = [ "ENVIRONMENTS", @@ -50,16 +59,6 @@ class Agentex(SyncAPIClient): - agents: agents.AgentsResource - tasks: tasks.TasksResource - messages: messages.MessagesResource - spans: spans.SpansResource - states: states.StatesResource - events: events.EventsResource - tracker: tracker.TrackerResource - with_raw_response: AgentexWithRawResponse - with_streaming_response: AgentexWithStreamedResponse - # client options api_key: str | None @@ -134,15 +133,55 @@ def __init__( _strict_response_validation=_strict_response_validation, ) - self.agents = agents.AgentsResource(self) - self.tasks = tasks.TasksResource(self) - self.messages = messages.MessagesResource(self) - self.spans = spans.SpansResource(self) - self.states = states.StatesResource(self) - self.events = events.EventsResource(self) - self.tracker = tracker.TrackerResource(self) - self.with_raw_response = AgentexWithRawResponse(self) - self.with_streaming_response = AgentexWithStreamedResponse(self) + @cached_property + def agents(self) -> AgentsResource: + from .resources.agents import AgentsResource + + return AgentsResource(self) + + @cached_property + def tasks(self) -> TasksResource: + from .resources.tasks import TasksResource + + return TasksResource(self) + + @cached_property + def messages(self) -> MessagesResource: + from .resources.messages import MessagesResource + + return MessagesResource(self) + + @cached_property + def spans(self) -> SpansResource: + from .resources.spans import SpansResource + + return SpansResource(self) + + @cached_property + def states(self) -> StatesResource: + from .resources.states import StatesResource + + return StatesResource(self) + + @cached_property + def events(self) -> EventsResource: + from .resources.events import EventsResource + + return EventsResource(self) + + @cached_property + def tracker(self) -> TrackerResource: + from .resources.tracker import TrackerResource + + return TrackerResource(self) + + @cached_property + def with_raw_response(self) -> AgentexWithRawResponse: + return AgentexWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AgentexWithStreamedResponse: + return AgentexWithStreamedResponse(self) @property @override @@ -254,16 +293,6 @@ def _make_status_error( class AsyncAgentex(AsyncAPIClient): - agents: agents.AsyncAgentsResource - tasks: tasks.AsyncTasksResource - messages: messages.AsyncMessagesResource - spans: spans.AsyncSpansResource - states: states.AsyncStatesResource - events: events.AsyncEventsResource - tracker: tracker.AsyncTrackerResource - with_raw_response: AsyncAgentexWithRawResponse - with_streaming_response: AsyncAgentexWithStreamedResponse - # client options api_key: str | None @@ -338,15 +367,55 @@ def __init__( _strict_response_validation=_strict_response_validation, ) - self.agents = agents.AsyncAgentsResource(self) - self.tasks = tasks.AsyncTasksResource(self) - self.messages = messages.AsyncMessagesResource(self) - self.spans = spans.AsyncSpansResource(self) - self.states = states.AsyncStatesResource(self) - self.events = events.AsyncEventsResource(self) - self.tracker = tracker.AsyncTrackerResource(self) - self.with_raw_response = AsyncAgentexWithRawResponse(self) - self.with_streaming_response = AsyncAgentexWithStreamedResponse(self) + @cached_property + def agents(self) -> AsyncAgentsResource: + from .resources.agents import AsyncAgentsResource + + return AsyncAgentsResource(self) + + @cached_property + def tasks(self) -> AsyncTasksResource: + from .resources.tasks import AsyncTasksResource + + return AsyncTasksResource(self) + + @cached_property + def messages(self) -> AsyncMessagesResource: + from .resources.messages import AsyncMessagesResource + + return AsyncMessagesResource(self) + + @cached_property + def spans(self) -> AsyncSpansResource: + from .resources.spans import AsyncSpansResource + + return AsyncSpansResource(self) + + @cached_property + def states(self) -> AsyncStatesResource: + from .resources.states import AsyncStatesResource + + return AsyncStatesResource(self) + + @cached_property + def events(self) -> AsyncEventsResource: + from .resources.events import AsyncEventsResource + + return AsyncEventsResource(self) + + @cached_property + def tracker(self) -> AsyncTrackerResource: + from .resources.tracker import AsyncTrackerResource + + return AsyncTrackerResource(self) + + @cached_property + def with_raw_response(self) -> AsyncAgentexWithRawResponse: + return AsyncAgentexWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncAgentexWithStreamedResponse: + return AsyncAgentexWithStreamedResponse(self) @property @override @@ -458,47 +527,199 @@ def _make_status_error( class AgentexWithRawResponse: + _client: Agentex + def __init__(self, client: Agentex) -> None: - self.agents = agents.AgentsResourceWithRawResponse(client.agents) - self.tasks = tasks.TasksResourceWithRawResponse(client.tasks) - self.messages = messages.MessagesResourceWithRawResponse(client.messages) - self.spans = spans.SpansResourceWithRawResponse(client.spans) - self.states = states.StatesResourceWithRawResponse(client.states) - self.events = events.EventsResourceWithRawResponse(client.events) - self.tracker = tracker.TrackerResourceWithRawResponse(client.tracker) + self._client = client + + @cached_property + def agents(self) -> agents.AgentsResourceWithRawResponse: + from .resources.agents import AgentsResourceWithRawResponse + + return AgentsResourceWithRawResponse(self._client.agents) + + @cached_property + def tasks(self) -> tasks.TasksResourceWithRawResponse: + from .resources.tasks import TasksResourceWithRawResponse + + return TasksResourceWithRawResponse(self._client.tasks) + + @cached_property + def messages(self) -> messages.MessagesResourceWithRawResponse: + from .resources.messages import MessagesResourceWithRawResponse + + return MessagesResourceWithRawResponse(self._client.messages) + + @cached_property + def spans(self) -> spans.SpansResourceWithRawResponse: + from .resources.spans import SpansResourceWithRawResponse + + return SpansResourceWithRawResponse(self._client.spans) + + @cached_property + def states(self) -> states.StatesResourceWithRawResponse: + from .resources.states import StatesResourceWithRawResponse + + return StatesResourceWithRawResponse(self._client.states) + + @cached_property + def events(self) -> events.EventsResourceWithRawResponse: + from .resources.events import EventsResourceWithRawResponse + + return EventsResourceWithRawResponse(self._client.events) + + @cached_property + def tracker(self) -> tracker.TrackerResourceWithRawResponse: + from .resources.tracker import TrackerResourceWithRawResponse + + return TrackerResourceWithRawResponse(self._client.tracker) class AsyncAgentexWithRawResponse: + _client: AsyncAgentex + def __init__(self, client: AsyncAgentex) -> None: - self.agents = agents.AsyncAgentsResourceWithRawResponse(client.agents) - self.tasks = tasks.AsyncTasksResourceWithRawResponse(client.tasks) - self.messages = messages.AsyncMessagesResourceWithRawResponse(client.messages) - self.spans = spans.AsyncSpansResourceWithRawResponse(client.spans) - self.states = states.AsyncStatesResourceWithRawResponse(client.states) - self.events = events.AsyncEventsResourceWithRawResponse(client.events) - self.tracker = tracker.AsyncTrackerResourceWithRawResponse(client.tracker) + self._client = client + + @cached_property + def agents(self) -> agents.AsyncAgentsResourceWithRawResponse: + from .resources.agents import AsyncAgentsResourceWithRawResponse + + return AsyncAgentsResourceWithRawResponse(self._client.agents) + + @cached_property + def tasks(self) -> tasks.AsyncTasksResourceWithRawResponse: + from .resources.tasks import AsyncTasksResourceWithRawResponse + + return AsyncTasksResourceWithRawResponse(self._client.tasks) + + @cached_property + def messages(self) -> messages.AsyncMessagesResourceWithRawResponse: + from .resources.messages import AsyncMessagesResourceWithRawResponse + + return AsyncMessagesResourceWithRawResponse(self._client.messages) + + @cached_property + def spans(self) -> spans.AsyncSpansResourceWithRawResponse: + from .resources.spans import AsyncSpansResourceWithRawResponse + + return AsyncSpansResourceWithRawResponse(self._client.spans) + + @cached_property + def states(self) -> states.AsyncStatesResourceWithRawResponse: + from .resources.states import AsyncStatesResourceWithRawResponse + + return AsyncStatesResourceWithRawResponse(self._client.states) + + @cached_property + def events(self) -> events.AsyncEventsResourceWithRawResponse: + from .resources.events import AsyncEventsResourceWithRawResponse + + return AsyncEventsResourceWithRawResponse(self._client.events) + + @cached_property + def tracker(self) -> tracker.AsyncTrackerResourceWithRawResponse: + from .resources.tracker import AsyncTrackerResourceWithRawResponse + + return AsyncTrackerResourceWithRawResponse(self._client.tracker) class AgentexWithStreamedResponse: + _client: Agentex + def __init__(self, client: Agentex) -> None: - self.agents = agents.AgentsResourceWithStreamingResponse(client.agents) - self.tasks = tasks.TasksResourceWithStreamingResponse(client.tasks) - self.messages = messages.MessagesResourceWithStreamingResponse(client.messages) - self.spans = spans.SpansResourceWithStreamingResponse(client.spans) - self.states = states.StatesResourceWithStreamingResponse(client.states) - self.events = events.EventsResourceWithStreamingResponse(client.events) - self.tracker = tracker.TrackerResourceWithStreamingResponse(client.tracker) + self._client = client + + @cached_property + def agents(self) -> agents.AgentsResourceWithStreamingResponse: + from .resources.agents import AgentsResourceWithStreamingResponse + + return AgentsResourceWithStreamingResponse(self._client.agents) + + @cached_property + def tasks(self) -> tasks.TasksResourceWithStreamingResponse: + from .resources.tasks import TasksResourceWithStreamingResponse + + return TasksResourceWithStreamingResponse(self._client.tasks) + + @cached_property + def messages(self) -> messages.MessagesResourceWithStreamingResponse: + from .resources.messages import MessagesResourceWithStreamingResponse + + return MessagesResourceWithStreamingResponse(self._client.messages) + + @cached_property + def spans(self) -> spans.SpansResourceWithStreamingResponse: + from .resources.spans import SpansResourceWithStreamingResponse + + return SpansResourceWithStreamingResponse(self._client.spans) + + @cached_property + def states(self) -> states.StatesResourceWithStreamingResponse: + from .resources.states import StatesResourceWithStreamingResponse + + return StatesResourceWithStreamingResponse(self._client.states) + + @cached_property + def events(self) -> events.EventsResourceWithStreamingResponse: + from .resources.events import EventsResourceWithStreamingResponse + + return EventsResourceWithStreamingResponse(self._client.events) + + @cached_property + def tracker(self) -> tracker.TrackerResourceWithStreamingResponse: + from .resources.tracker import TrackerResourceWithStreamingResponse + + return TrackerResourceWithStreamingResponse(self._client.tracker) class AsyncAgentexWithStreamedResponse: + _client: AsyncAgentex + def __init__(self, client: AsyncAgentex) -> None: - self.agents = agents.AsyncAgentsResourceWithStreamingResponse(client.agents) - self.tasks = tasks.AsyncTasksResourceWithStreamingResponse(client.tasks) - self.messages = messages.AsyncMessagesResourceWithStreamingResponse(client.messages) - self.spans = spans.AsyncSpansResourceWithStreamingResponse(client.spans) - self.states = states.AsyncStatesResourceWithStreamingResponse(client.states) - self.events = events.AsyncEventsResourceWithStreamingResponse(client.events) - self.tracker = tracker.AsyncTrackerResourceWithStreamingResponse(client.tracker) + self._client = client + + @cached_property + def agents(self) -> agents.AsyncAgentsResourceWithStreamingResponse: + from .resources.agents import AsyncAgentsResourceWithStreamingResponse + + return AsyncAgentsResourceWithStreamingResponse(self._client.agents) + + @cached_property + def tasks(self) -> tasks.AsyncTasksResourceWithStreamingResponse: + from .resources.tasks import AsyncTasksResourceWithStreamingResponse + + return AsyncTasksResourceWithStreamingResponse(self._client.tasks) + + @cached_property + def messages(self) -> messages.AsyncMessagesResourceWithStreamingResponse: + from .resources.messages import AsyncMessagesResourceWithStreamingResponse + + return AsyncMessagesResourceWithStreamingResponse(self._client.messages) + + @cached_property + def spans(self) -> spans.AsyncSpansResourceWithStreamingResponse: + from .resources.spans import AsyncSpansResourceWithStreamingResponse + + return AsyncSpansResourceWithStreamingResponse(self._client.spans) + + @cached_property + def states(self) -> states.AsyncStatesResourceWithStreamingResponse: + from .resources.states import AsyncStatesResourceWithStreamingResponse + + return AsyncStatesResourceWithStreamingResponse(self._client.states) + + @cached_property + def events(self) -> events.AsyncEventsResourceWithStreamingResponse: + from .resources.events import AsyncEventsResourceWithStreamingResponse + + return AsyncEventsResourceWithStreamingResponse(self._client.events) + + @cached_property + def tracker(self) -> tracker.AsyncTrackerResourceWithStreamingResponse: + from .resources.tracker import AsyncTrackerResourceWithStreamingResponse + + return AsyncTrackerResourceWithStreamingResponse(self._client.tracker) Client = Agentex