uni-robot-agent-runtime 0.1.1__tar.gz

uni_robot_agent_runtime-0.1.1/.github/workflows/release.yml

@@ -0,0 +1,150 @@
+name: Package checks and manual release
+
+on:
+  pull_request:
+  push:
+    branches: [main, release/open-source]
+  workflow_dispatch:
+    inputs:
+      publish_to:
+        description: Upload destination (none only builds and checks)
+        type: choice
+        required: true
+        default: none
+        options: [none, testpypi, pypi]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: package-${{ github.ref }}-${{ inputs.publish_to || 'none' }}
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7.0.1
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v7.1.0
+        with:
+          python-version: '3.11'
+      - run: python -m pip install 'build>=1' 'twine>=6' 'tomli-w>=1'
+      - name: Build and validate candidate
+        env:
+          PUBLISH_TO: ${{ inputs.publish_to || 'none' }}
+          REF_TYPE: ${{ github.ref_type }}
+          REF_NAME: ${{ github.ref_name }}
+        shell: bash
+        run: |
+          args=()
+          if [[ "$PUBLISH_TO" != none ]]; then
+            if [[ "$REF_TYPE" != tag ]]; then
+              echo 'Publishing requires a version tag; branch runs only support publish_to=none.' >&2
+              exit 1
+            fi
+            args+=(--tag "$REF_NAME")
+          fi
+          python scripts/release/prepare.py --output-dir "$RUNNER_TEMP/release" "${args[@]}"
+      - uses: actions/upload-artifact@v7.0.2
+        with:
+          name: python-distributions
+          path: ${{ runner.temp }}/release/dist/*
+          if-no-files-found: error
+      - uses: actions/upload-artifact@v7.0.2
+        with:
+          name: release-manifest
+          path: |
+            ${{ runner.temp }}/release/release.json
+            ${{ runner.temp }}/release/SHA256SUMS
+          if-no-files-found: error
+
+  install:
+    needs: build
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            python: '3.11'
+            installer: pip
+          - os: ubuntu-latest
+            python: '3.12'
+            installer: pip
+          - os: ubuntu-latest
+            python: '3.12'
+            installer: uv
+          - os: macos-14
+            python: '3.12'
+            installer: pip
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v7.0.1
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v7.1.0
+        with:
+          python-version: ${{ matrix.python }}
+      - uses: actions/download-artifact@v8.0.2
+        with:
+          name: python-distributions
+          path: dist
+      - if: matrix.installer == 'uv'
+        run: python -m pip install uv
+      - name: Install wheel outside checkout and validate CLI and SDK
+        env:
+          INSTALLER: ${{ matrix.installer }}
+        run: python scripts/validation/sdk_release.py dist/uni_robot_agent-[0-9]*.whl "$RUNNER_TEMP/sdk-check" --installer "$INSTALLER"
+      - name: Check upgrade from the initial release and clean uninstall
+        env:
+          INSTALLER: ${{ matrix.installer }}
+        run: python scripts/validation/sdk_release.py dist/uni_robot_agent-[0-9]*.whl "$RUNNER_TEMP/upgrade-check" --installer "$INSTALLER" --upgrade-from 0.1.0
+      - name: Verify isolated native dependency contract
+        run: python scripts/validation/runtime_release.py dist/uni_robot_agent_runtime-*.whl "$RUNNER_TEMP/runtime-check" --main-wheel dist/uni_robot_agent-[0-9]*.whl
+      - name: Check isolated uv CLI installation
+        if: matrix.installer == 'uv'
+        env:
+          UV_TOOL_DIR: ${{ runner.temp }}/uv-tools
+          UV_TOOL_BIN_DIR: ${{ runner.temp }}/uv-bin
+        shell: bash
+        run: |
+          uv tool install --python "$(command -v python)" dist/uni_robot_agent-[0-9]*.whl
+          cd "$RUNNER_TEMP"
+          "$UV_TOOL_BIN_DIR/uni-robot-agent" --version
+          "$UV_TOOL_BIN_DIR/uni-robot-agent" run --integration robodojo --model validation-model \
+            --env-url http://127.0.0.1:18760 --no-sam3 --validate-config
+
+  publish:
+    # No push, pull request, tag creation, or default manual run uploads a package.
+    if: >-
+      github.event_name == 'workflow_dispatch' &&
+      (inputs.publish_to == 'pypi' || inputs.publish_to == 'testpypi') &&
+      github.ref_type == 'tag'
+    needs: [build, install]
+    runs-on: ubuntu-latest
+    environment:
+      name: ${{ inputs.publish_to }}
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v8.0.2
+        with:
+          name: python-distributions
+          path: dist
+      - name: Separate native and planner distributions
+        run: |
+          mkdir runtime-dist planner-dist
+          mv dist/uni_robot_agent_runtime-* runtime-dist/
+          mv dist/uni_robot_agent-* planner-dist/
+      - name: Upload the native runtime with Trusted Publishing
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: runtime-dist/
+          skip-existing: true
+          repository-url: ${{ inputs.publish_to == 'testpypi' && 'https://test.pypi.org/legacy/' || 'https://upload.pypi.org/legacy/' }}
+      - name: Upload the checked archives with Trusted Publishing
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: planner-dist/
+          repository-url: ${{ inputs.publish_to == 'testpypi' && 'https://test.pypi.org/legacy/' || 'https://upload.pypi.org/legacy/' }}

uni_robot_agent_runtime-0.1.1/AGENTS.md

@@ -0,0 +1,91 @@
+# Development instructions
+
+These instructions apply to agents developing this repository. They are not
+robot-task instructions, runtime skills, or permission to operate hardware.
+When running a robot episode, use its assembled prompt and registered tools;
+do not treat this document as a request to edit code during the episode.
+
+## Before changing code
+
+- Check the checkout, branch, status, and relevant diff. Preserve other work;
+  stage only task-owned changes when a commit is requested.
+- Read [the architecture and diagram](docs/architecture.md), then
+  [development boundaries](docs/development.md) for the affected layer.
+- For environment work, also read [integration contracts](docs/integrations.md).
+  For planner SDK work, read [agent integration](docs/agents.md).
+- Identify the owner of each new behavior before implementing it. Existing
+  code is evidence, not permission to copy a boundary violation.
+
+## Architecture and extension points
+
+All components can evolve, including existing gripper tools. Keep each behavior
+in its owning layer and make cross-layer contracts explicit. The current tool
+families are examples of this architecture, not a closed list of allowed tools.
+
+| Layer | Responsibility |
+|---|---|
+| `cli.py`, `config.py`, `session.py` | Resolve configuration and assemble/own the run lifecycle |
+| `agents/` | Adapt planner SDKs, deliver tool calls through the executor, translate SDK events and records |
+| `provider/` | Connect model APIs: gateway, wire conversion, model-request retry and response delivery |
+| `context/` | Assemble prompts/history and apply context policies |
+| `tools/` | Define model-visible tool schemas, handlers, orchestration, feedback and resource requirements |
+| `execution/` | Schedule tool work, enforce resource exclusion and manage background jobs |
+| `integrations/` | Compose tool families and adapt native environments, controllers, observations and model/resource bindings |
+| `services/` | Own typed service contracts, clients, hosts and environment/model service lifecycles |
+| `observation/` | Coordinate observation collection, freshness and observer insights |
+| `events/` | Define and distribute shared execution events |
+| `artifacts/` | Store run artifacts and support persistence/export |
+| `telemetry/` | Record traces, logs and diagnostics |
+| `ui/` | Present state/events and route user intent through the session interfaces |
+| `resources/` | Package robot-facing prompts and runtime skills |
+
+- To change robot behavior, modify or add tools in an existing tool set, or
+  create `tools/<family>/` for a new tool set. Keep reusable behavior there even
+  when the first user is one environment. Avoid concrete integration imports;
+  accept domain contracts and bindings instead.
+- Environments provide native execution/data and compose shared providers;
+  they do not define model tools or hide tool-name dispatch inside bindings.
+  Reuse existing episode/service infrastructure and extend its contracts when
+  needed. Services expose domain operations, not a copy of the model tool API.
+- Reuse compatible observation contracts and scene tools. Extend them or add
+  a tool family for a different agent capability; native sensor setup belongs
+  in the adapter. Expose only capabilities the selected environment supports.
+- Keep SDK-specific behavior in `agents/`, upstream wire differences in
+  `provider/`, and scheduling in `execution/`. Rendering and logging consume
+  shared state/events; they do not implement robot control.
+- Keep native dependencies at service/startup boundaries so CLI help and offline
+  configuration validation do not require robot or model runtimes.
+
+## Compatibility and validation
+
+- Intentional behavior changes are welcome: document the new contract, affected
+  users and any migration, then update tests/docs. For a behavior-preserving
+  refactor, compare tool schemas/visibility, prompts, feedback, defaults, budgets,
+  ordering and outcomes. Neither existing tools nor public APIs are frozen.
+- Check affected callers and unsupported-capability cases when changing shared
+  contracts. Scale regression coverage to the change rather than requiring a
+  full benchmark for every contribution.
+- Preserve command identity, state ownership and receipt reconciliation. A lost
+  physical acknowledgement does not justify replaying a motion. Distinguish
+  tool completion, agent completion and environment task success.
+- Use English for code comments, docstrings, model-facing text, and repository
+  documentation. Prefer explicit types and small functions; avoid speculative
+  compatibility layers. Follow [Contributing](CONTRIBUTING.md) for setup.
+- Run relevant validation and report failures/skips honestly. Follow
+  [the validation matrix](docs/development.md#validation-and-review) and add focused
+  tests for new behavior. CPU checks are not evidence of real-hardware success.
+- Do not put credentials, machine-specific deployment paths, or experiment
+  outputs in source. Preserve upstream attribution and native resource formats.
+
+## Code Review Rules
+
+Flag integration-local model tools, generic `execute_tool(name, args)` service
+routes, tool-family imports of native integrations, duplicated episode state,
+unsupported capabilities advertised to the planner, SDK-specific decisions in
+generic scheduling, and robot control implemented in UI/telemetry. Review changes
+to shared contracts for affected callers and migration, not for conformity to
+an immutable tool list. For migrations, account for retained, replaced and
+deliberately removed features.
+
+Maintain shared rules here. `CLAUDE.md` only imports this file. Keep detailed
+extension recipes in `docs/development.md` and update them with the contracts.

uni_robot_agent_runtime-0.1.1/CHANGELOG.md

@@ -0,0 +1,104 @@
+# Changelog
+
+## 0.1.1 — 2026-11-04
+
+- Generate native CuRobo robot configs during setup in a private asset overlay;
+  shared downloaded assets remain unchanged. Detect missing configs before launch.
+- Accept the audited X5 URDF's byte-equivalent CRLF snapshot alongside its LF
+  form, retaining exact mesh checks and checking these assets before GPU startup.
+
+- Install a matching `uni-robot-agent-runtime` in native service environments,
+  excluding planner SDK and UI dependencies while preserving the main CLI/SDK.
+- Align RoboDojo and RoboUse Factory FastAPI/Uvicorn constraints with Isaac Sim
+  5.1; retain strict dependency checks.
+- Build both distributions from one source tree and verify independent sdists,
+  resource parity, native HTTP hosting, and upgrades from 0.1.0.
+- Build the pinned IsaacLab fork with a documented, checksum-guarded Starlette
+  metadata correction and a local version suffix, preserving native module bytes.
+- Install all IsaacLab base extensions and verify their required imports before
+  marking the simulator runtime ready.
+- `setup --wheel` now requires the runtime wheel at the CLI version.
+
+Known issue: on containers that do not reap zombie descendants, SDK shutdown
+can wait about 35 extra seconds and report forced cleanup after the simulator
+has exited. The validated runs left no live simulator or GPU allocation behind.
+
+## 0.1.0 — 2026-11-03
+
+Initial open-source release of uni-robot-agent, a robot agent built on Codex and
+Claude Code.
+
+### Agent and robot tools
+
+- Default RoboDojo task supplements to the simplified instruction_supplements
+  catalog; retain the full task_requirements catalog as a reference. Keep its
+  CLI switch and Python configuration field exclusive to RoboDojo.
+- Support pure RGB RoboDojo observations with depth and camera calibration disabled;
+  expose only 2D segmentation and retain robot proprioception and robot geometry.
+- Wait for calibrated camera data alongside RGB when capturing RoboDojo scenes,
+  including with depth disabled. Capture errors report no physical execution
+  and allow subsequent actions instead of leaving the client locked.
+- Guide RoboDojo planners to reposition a free arm for a clearer wrist-camera
+  view, then recapture calibrated observations and use the updated extrinsics.
+- Observe scenes, plan actions and execute manipulation tasks through shared
+  perception, motion, skill and completion tools.
+- Use Direct motion or RoboDojo Hybrid control with Pi0.5 proposals and an optional
+  reviewer. Preserve execution receipts and report partial execution explicitly.
+- Read shared and environment skills; write environment-local experience only
+  when an external skill library and skill writing are explicitly enabled.
+- Connect model providers through protocol adapters while preserving tool identity,
+  call/result pairing and available model traces.
+
+### CLI, SDK and monitoring
+
+- Reject camera-calibration overrides outside RoboDojo environment deployment,
+  including connections to an existing service, instead of silently ignoring them.
+- Document episode timeout start points separately for external services and
+  managed local deployment.
+
+- Simplify the Hybrid example to use normal budgets and task supplements;
+  exclude default run artifacts from Git.
+- Add minimal RoboDojo, RoboLab and RoboUse episode scripts with preparation
+  instructions, explicit model selection and offline configuration checks.
+- Select the Codex calculation interpreter with `--agent-python`, independently
+  of the agent runtime and service interpreters.
+- Prepare isolated runtimes and resources with `setup`; start environment, actor
+  and SAM3 services separately with `deploy`; use `run --deploy local` to run the
+  agent on one task and clean up owned processes.
+- Expose typed Python configuration, direct tools and queued jobs, built-in agent
+  execution, events, saved results, and explicit setup/deployment APIs.
+- Monitor live runs and replay result directories locally, including synchronized
+  camera views, tool batches, resource queues and native outcome/step metrics.
+  Multiple saved directories open a card overview; replay does not launch tasks.
+- Preserve completed Codex counters and finalize model records on interruption
+  before propagating cancellation to the caller.
+- Keep tool success, agent completion and native task success distinct. Record
+  explicit false outcomes, zero counters and storage failures without replacing
+  the original execution outcome.
+
+### Distribution
+
+- Remove the unimplemented physical-home entry point and obsolete RoboUse test
+  claims; document the worker interpreter's required installed package.
+- Make source launchers prefer their own checkout over inherited Python paths.
+- Supply RoboDojo observation guidance from its integration, keeping shared
+  observation code independent of environment names.
+
+- Remove experiment-specific provider bridging and obsolete diagnostic probes
+  from the public distribution.
+- Prepare checked release candidates and SHA-256 manifests without uploading;
+  run Linux/macOS installation checks and explicitly dispatch tagged releases
+  to PyPI or TestPyPI through Trusted Publishing.
+- Document package-index installation for the CLI and SDK, matching-version
+  runtime setup, and source/wheel installation before the first publication.
+
+- Include official RoboDojo and RoboUse runtime recipes; LIBERO tasks use RoboUse.
+  Other included adapters retain their existing connection workflows and stated
+  validation limits. See [integrations](docs/integrations.md).
+- Include SDK type information, prompts, skills and local monitoring resources,
+  plus a standalone installation/configuration validator.
+- Use `uni-robot-agent` for the distribution/CLI and `uni_robot_agent` for imports.
+- Use `UNI_ROBOT_AGENT_*` configuration and consistent names for actor protocols,
+  RoboUse workers, tool metadata and default storage paths. Update agent and
+  service runtimes together; select existing pose libraries with `--store` or
+  `--hand-pose-store`. New provider records use trace format 5.

uni_robot_agent_runtime-0.1.1/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

uni_robot_agent_runtime-0.1.1/CONTRIBUTING.md

@@ -0,0 +1,74 @@
+# Contributing
+
+Contributions to uni-robot-agent are welcome. The distribution and CLI are
+`uni-robot-agent`; Python imports use `uni_robot_agent`.
+
+## Agent-assisted development
+
+Start with [AGENTS.md](AGENTS.md) and the
+[development boundaries and extension guide](docs/development.md). They define
+directory ownership, the environment/tool/service boundary, and compatibility
+checks for new robots and planners. `CLAUDE.md` imports the same instructions
+for Claude Code; maintain the rules in one place. Read these before adapting a
+standalone native implementation into the harness.
+
+## Development setup
+
+Clone the public source branch first:
+
+```bash
+git clone https://github.com/Open-RUA/uni-robot-agent.git
+cd uni-robot-agent
+```
+
+Use a dedicated environment and run the following commands from the repository root.
+See [Getting started](docs/getting-started.md) for platform notes and external
+service requirements. Use Python 3.11+:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -e '.[dev,robodojo]'
+uni-robot-agent run --integration robodojo --model test-model \
+  --env-url http://127.0.0.1:18760 --no-sam3 --validate-config
+python -m build
+```
+
+Follow [packaging checks](docs/packaging.md) to verify release contents, standalone
+installation and offline SDK configuration. Add focused tests with new behavior
+and keep them under `tests/`. Native simulators, model inference and hardware need
+separate runtime validation. A successful package build is not benchmark evidence.
+
+For a release candidate, use the [build-only preparation command](docs/packaging.md#prepare-a-release-candidate-without-publishing).
+Release maintainers should follow [the first-release sequence](docs/publishing.md#first-release-sequence):
+finish documentation, finalize public history and repository layout, then build
+and publish from the final commit.
+
+## Changes and pull requests
+
+- Keep each change focused; explain the problem, resulting behavior and validation.
+- Use English for comments, docstrings, user messages and documentation.
+- Keep shared tool semantics in `uni_robot_agent/tools/`, environment and embodiment
+  behavior in `uni_robot_agent/integrations/`, transport in `uni_robot_agent/services/`,
+  and SDK-specific behavior in `uni_robot_agent/agents/`. Follow the [architecture](docs/architecture.md) and
+  [environment integration contracts](docs/integrations.md#integration-contract).
+- Preserve physical-action ordering, resource ownership and no-replay guarantees.
+  Keep tool completion distinct from task success and official environment outcomes.
+- Treat prompts, skills and model-visible feedback as behavior changes; identify
+  their experimental impact separately from documentation or formatting edits.
+- Run tests relevant to the change. Check package builds when dependencies,
+  metadata or packaged resources change; update the changelog for user-facing changes.
+- Preserve upstream licenses and attribution when adapting external code.
+
+## Reporting issues
+
+Include the revision, Python/platform, installation extras, relevant configuration,
+minimal reproduction and expected versus observed behavior. Remove credentials
+and private data from logs; a complete experiment directory is usually unnecessary.
+
+## License
+
+uni-robot-agent is released under the [MIT License](LICENSE). Contributions are made
+under the same license. Preserve upstream notices for adapted code, including
+the [RoboDojo](uni_robot_agent/integrations/robodojo/UPSTREAM_LICENSE) notices.
+External simulators, assets, and checkpoints retain their own licenses.

uni_robot_agent_runtime-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 uni-robot-agent contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

uni_robot_agent_runtime-0.1.1/MANIFEST.in

@@ -0,0 +1,13 @@
+include README.md CHANGELOG.md CONTRIBUTING.md AGENTS.md CLAUDE.md pyrightconfig.json
+recursive-include docs *.md
+recursive-include .github/workflows *.yml
+recursive-include assets *.md *.png *.html *.pdf *.sh *.txt
+recursive-include scripts *.sh *.py *.json *.md *.txt *.toml
+recursive-exclude * __pycache__ *.py[cod]
+prune uni_robot_agent/integrations/robodojo/resources
+recursive-include examples *.sh *.py *.json *.toml *.md
+prune archive
+
+
+recursive-include uni_robot_agent/integrations *.toml
+recursive-include uni_robot_agent/services *.toml

uni_robot_agent_runtime-0.1.1/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: uni-robot-agent-runtime
+Version: 0.1.1
+Summary: Native service runtime for uni-robot-agent; install in a separate environment
+License-Expression: MIT
+Project-URL: Documentation, https://uni-robot-agent.com/docs
+Project-URL: Homepage, https://uni-robot-agent.com/
+Keywords: robotics,agents,mcp,embodied-ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0.0
+Requires-Dist: huggingface-hub<2,>=0.28
+Requires-Dist: numpy>=1.24
+Requires-Dist: pillow>=10
+Requires-Dist: pydantic<3,>=2
+Requires-Dist: jsonschema>=4.18
+Requires-Dist: httpx<1,>=0.28
+Requires-Dist: fastapi<1,>=0.115
+Requires-Dist: uvicorn<1,>=0.29
+Dynamic: license-file
+
+# uni-robot-agent runtime
+
+Native service runtime for [uni-robot-agent](https://pypi.org/project/uni-robot-agent/).
+For the CLI and Python SDK, install `uni-robot-agent` instead.
+
+The CLI's explicit `setup` command installs this package at the matching version
+in a separate native environment, alongside simulator or model dependencies.
+This distribution excludes planner SDK and terminal UI dependencies so native
+runtimes can retain their own compatible versions of shared libraries.
+
+Both packages are built from the same source and contain the same
+`uni_robot_agent` modules. **Never install both in the same Python environment.**
+Neither package depends on the other. Simulators, assets, checkpoints and GPU
+drivers are separate prerequisites.
+
+See the [documentation](https://uni-robot-agent.com/docs) for setup and usage.