fix(agent): trust the resolved livekit-agents version in the SDK check; add Windows test runner (#894)

* fix(agentfs): parse resolved livekit-agents version from uv.lock

checkUvLock matched a `livekit-agents = "x"` line that never appears in
uv.lock. uv.lock uses poetry.lock's TOML layout ([[package]] / name / version),
so the resolved version was never found, and the SDK version check fell back to
the pyproject.toml constraint floor — reading `>=1.0` as 1.0 and rejecting it
as older than the minimum (e.g. 1.6.0) even when the lock resolved a newer
version. Use the same [[package]] block regex as checkPoetryLock so the
resolved version is read and preferred, matching how the Node lockfile parsers
already read the installed version.

Also replaces the test's fake uv.lock fixture with the real format and adds a
regression test for the pyproject-floor-vs-resolved-version case.

* feat(agent): resolve installed livekit-agents version for Python run check

lk agent start/dev/console gated the Python SDK version by parsing project
files, which can't know the resolved version from a loose constraint (and
misread e.g. >=1.0 as 1.0). Resolve the installed version via the project
interpreter (importlib.metadata) like the Node path already does, so the check
reflects what will actually run regardless of installer. Falls back to static
file parsing when dependencies aren't installed (e.g. before a sync). uv reads
the existing env with --no-sync so the pre-flight check never syncs/downloads.

* ci: share one Windows cross-build between unit tests and session e2e

Combine the two Windows cross-builds into a single zig cross-build job in
windows.yaml that produces lk.exe plus a test binary per package. Both the
unit-test run (windows-tests) and the session e2e run (windows-session-e2e)
depend on it, so the expensive cgo compile happens once. Move the Windows jobs
out of session-e2e.yaml (now Linux/macOS only) and fold the standalone
test-windows.yaml in.

* fix(agent): never sync the uv environment as a launch side effect

The CLI proxies the project's local environment; `uv run` implicitly
re-locking and installing packages when launching an agent is a
surprising side effect (and can change dependency versions mid-debug).
Move --no-sync into findPythonBinary so both the version pre-flight and
the launch run against the environment as it exists on disk.

Since the launch no longer installs missing dependencies, the version
probe now distinguishes "interpreter ran but livekit-agents isn't
installed" and the pre-flight fails fast with a `uv sync` hint
instead of letting the agent die with ModuleNotFoundError.

* docs(e2e): fix stale auto-sync note on the echo-agent fixture

The launch path now uses `uv run --no-sync`; deps come from the
explicit `uv sync` step in CI.

* fix(console): clear the spinner line before stopSpinner returns

Stopping only signaled the spinner goroutine, which could sleep up to
80ms before clearing the line — so an error printed right after landed
on the leftover "Starting agent" text. Block the stop function until
the clear escape has been written.

Author: u9g

.github/workflows/session-e2e.yaml

@@ -1,10 +1,11 @@
 name: Session E2E
 
 # Drives the real `lk agent daemon` start/say/stop lifecycle against the minimal
-# one-file echo agents in cmd/lk/testdata, on Linux, macOS, and Windows. This
-# exercises the detached daemon, the readiness handshake, the console IPC
-# transport, and the model round-trip end to end -- runtime behavior that
-# `go test` alone never covers.
+# one-file echo agents in cmd/lk/testdata, on Linux and macOS (the Windows arm
+# lives in windows.yaml, which cross-compiles with zig). This exercises the
+# detached daemon, the readiness handshake, the console IPC transport, and the
+# model round-trip end to end -- runtime behavior that `go test` alone never
+# covers.
 #
 # Both agent runtimes are exercised via the `lang` matrix dimension: Python
 # (testdata/echo-agent, the test's default) and Node (testdata/echo-agent-node,
@@ -22,16 +23,6 @@ name: Session E2E
 # fixture via `uv sync` from its pyproject.toml; the Node fixture via
 # `npm install` from its package.json. The Node `.ts` entrypoint runs through
 # Node's --experimental-strip-types loader, which needs Node >= 22.6.
-#
-# Windows is split into two jobs: pkg/apm/webrtc's C++ uses MSVC SEH
-# (__try/__except) that the runner's mingw GCC can't compile, so we build with
-# zig (clang) exactly as .goreleaser.yaml does. zig-as-CC must run on Linux: on
-# native Windows the cgo link of ~560 webrtc/portaudio objects overflows the
-# ~32KB command-line limit. So `cross-build-windows` cross-compiles lk.exe AND
-# the e2e test binary on Linux and uploads them; `e2e-windows` downloads them
-# and runs the test natively (LK_SESSION_E2E_BIN points the test at the
-# prebuilt lk, so nothing is rebuilt on the Windows runner). The binaries are
-# language-agnostic, so that build runs once and feeds every `lang` arm.
 
 on:
   workflow_dispatch:
@@ -114,135 +105,3 @@ jobs:
           # Resolved relative to cmd/lk, the test binary's working directory.
           LK_SESSION_E2E_AGENT: ${{ matrix.lang == 'node' && 'testdata/echo-agent-node/agent.ts' || '' }}
         run: go test ./cmd/lk -run TestSessionE2E -count=1 -v -timeout 600s
-
-  # Cross-compile the Windows artifacts on Linux with zig, mirroring
-  # .goreleaser.yaml's lk-windows-amd64 build. Produces lk.exe (the binary under
-  # test) and the compiled e2e test binary, both shipped to e2e-windows.
-  cross-build-windows:
-    runs-on: ubuntu-latest
-    name: Cross-build Windows artifacts (zig)
-
-    permissions:
-      contents: read
-
-    steps:
-      - name: Checkout livekit-cli
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
-        with:
-          submodules: true
-
-      - name: Set up Zig
-        uses: mlugg/setup-zig@d1434d08867e3ee9daa34448df10607b98908d29 # v2
-        with:
-          version: 0.14.1
-
-      - name: Set up Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6
-        with:
-          go-version-file: go.mod
-          cache: true
-
-      # Generate the MinGW import libs lld needs for Go's /DEFAULTLIB references
-      # (dbghelp, bcrypt, ...), exactly as goreleaser's before-hook does.
-      - name: Generate MinGW import libs
-        run: scripts/setup-cross.sh windows/amd64
-
-      - name: Cross-compile lk.exe and the e2e test binary
-        env:
-          GOOS: windows
-          GOARCH: amd64
-          CGO_ENABLED: "1"
-          # zig cc/c++ as the cgo toolchain, matching .goreleaser.yaml's Windows
-          # build. -fms-extensions (SEH) isn't on cgo's allowlist; -fno-sanitize
-          # is a zig UBSan-under-lld workaround -- both copied from goreleaser.
-          CC: zig cc -target x86_64-windows-gnu
-          CXX: zig c++ -target x86_64-windows-gnu
-          CGO_CXXFLAGS_ALLOW: -fms-extensions
-          CGO_CXXFLAGS: -fno-sanitize=all
-        run: |
-          ldflags="-extldflags=-L$PWD/.cross/windows_amd64/mingw_lib"
-          mkdir -p dist
-          go build -ldflags="$ldflags" -o dist/lk.exe ./cmd/lk
-          go test -c -ldflags="$ldflags" -o dist/session-e2e.test.exe ./cmd/lk
-
-      - name: Upload Windows artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: windows-e2e
-          path: dist/*.exe
-          retention-days: 1
-          if-no-files-found: error
-
-  # Run the prebuilt Windows artifacts natively. No Go/zig/cgo here: the test
-  # binary just drives lk.exe (via LK_SESSION_E2E_BIN) against the echo agent.
-  e2e-windows:
-    needs: cross-build-windows
-    runs-on: windows-latest
-    name: Agent Session with ${{ matrix.lang }} Agent on windows-latest
-
-    strategy:
-      fail-fast: false
-      matrix:
-        lang: [python, node]
-
-    permissions:
-      contents: read
-
-    steps:
-      - name: Checkout livekit-cli
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
-        # No submodules: the prebuilt binaries already contain the cgo code;
-        # only the echo-agent fixtures (plain repo files) are needed at runtime.
-
-      - name: Download Windows artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: windows-e2e
-          path: dist
-
-      - name: Set up Python
-        if: matrix.lang == 'python'
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-
-      - name: Set up uv
-        if: matrix.lang == 'python'
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-
-      - name: Sync echo agent deps
-        if: matrix.lang == 'python'
-        working-directory: cmd/lk/testdata/echo-agent
-        run: uv sync
-
-      - name: Set up Node
-        if: matrix.lang == 'node'
-        uses: actions/setup-node@v4
-        with:
-          # --experimental-strip-types (used to run the .ts entrypoint) needs >= 22.6.
-          node-version: "22"
-
-      - name: Install Node echo agent deps
-        if: matrix.lang == 'node'
-        working-directory: cmd/lk/testdata/echo-agent-node
-        run: npm install
-
-      - name: Run session e2e
-        # Run from cmd/lk so the test's relative testdata/ entrypoint paths
-        # resolve; point it at the cross-built lk.exe so nothing rebuilds.
-        shell: bash
-        working-directory: cmd/lk
-        env:
-          # Relative to cmd/lk; Go's filepath.Abs resolves it. Forward slashes
-          # keep bash happy (GITHUB_WORKSPACE would carry Windows backslashes).
-          LK_SESSION_E2E_BIN: ../../dist/lk.exe
-          LIVEKIT_API_KEY: ${{ secrets.LIVEKIT_API_KEY }}
-          LIVEKIT_API_SECRET: ${{ secrets.LIVEKIT_API_SECRET }}
-          LIVEKIT_URL: ${{ secrets.LIVEKIT_URL }}
-          # Default (unset) targets the Python fixture; point at the Node one for that arm.
-          LK_SESSION_E2E_AGENT: ${{ matrix.lang == 'node' && 'testdata/echo-agent-node/agent.ts' || '' }}
-        run: |
-          ../../dist/session-e2e.test.exe \
-            -test.run TestSessionE2E -test.count=1 -test.v -test.timeout 600s

.github/workflows/windows.yaml

@@ -0,0 +1,218 @@
+name: Windows
+
+# All Windows CI for the repo. test.yaml covers Linux/macOS Go tests and the
+# `e2e` job in session-e2e.yaml covers Linux/macOS session e2e; Windows is here.
+#
+# pkg/apm/webrtc's C++ uses MSVC SEH (__try/__except) that the runner's mingw GCC
+# can't compile, and on native Windows the cgo link of ~560 webrtc/portaudio
+# objects overflows the ~32KB command-line limit. So -- exactly like
+# .goreleaser.yaml -- everything is cross-compiled on Linux with zig (clang) in a
+# single `cross-build` job, then run natively on windows-latest. Both consumers
+# (the unit-test run and the session e2e run) depend on that one build, so the
+# expensive cgo compile happens once.
+
+on:
+  push:
+    branches: ['**']
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+concurrency:
+  group: windows-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  # Cross-compile lk.exe and a test binary per package on Linux with zig.
+  # manifest.tsv maps each test binary to its package directory so the unit-test
+  # job can run it from there (tests read cwd-relative fixtures, e.g.
+  # cmd/lk/testdata and pkg/agentfs/examples).
+  cross-build:
+    runs-on: ubuntu-latest
+    name: Cross-build Windows artifacts (zig)
+
+    permissions:
+      contents: read
+
+    steps:
+      - name: Checkout livekit-cli
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        with:
+          # pkg/portaudio/pa_src is a submodule with the vendored PortAudio C
+          # source linked into cmd/lk via cgo.
+          submodules: true
+
+      - name: Set up Zig
+        uses: mlugg/setup-zig@d1434d08867e3ee9daa34448df10607b98908d29 # v2
+        with:
+          version: 0.14.1
+
+      - name: Set up Go
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6
+        with:
+          go-version-file: go.mod
+          cache: true
+
+      # Generate the MinGW import libs lld needs for Go's /DEFAULTLIB references
+      # (dbghelp, bcrypt, ...), exactly as goreleaser's before-hook does.
+      - name: Generate MinGW import libs
+        run: scripts/setup-cross.sh windows/amd64
+
+      - name: Cross-compile lk.exe and per-package test binaries
+        env:
+          GOOS: windows
+          GOARCH: amd64
+          CGO_ENABLED: "1"
+          # zig cc/c++ as the cgo toolchain, matching .goreleaser.yaml's Windows
+          # build. -fms-extensions (SEH) isn't on cgo's allowlist; -fno-sanitize
+          # is a zig UBSan-under-lld workaround -- both copied from goreleaser.
+          CC: zig cc -target x86_64-windows-gnu
+          CXX: zig c++ -target x86_64-windows-gnu
+          CGO_CXXFLAGS_ALLOW: -fms-extensions
+          CGO_CXXFLAGS: -fno-sanitize=all
+        run: |
+          set -euo pipefail
+          ldflags="-extldflags=-L$PWD/.cross/windows_amd64/mingw_lib"
+          module=$(go list -m)
+          mkdir -p dist
+          go build -ldflags="$ldflags" -o dist/lk.exe ./cmd/lk
+          : > dist/manifest.tsv
+          for pkg in $(go list -f '{{if or .TestGoFiles .XTestGoFiles}}{{.ImportPath}}{{end}}' ./...); do
+            rel=${pkg#"$module"/}
+            [ "$rel" = "$module" ] && rel="."
+            safe=$(echo "$rel" | tr '/' '_')
+            go test -c -ldflags="$ldflags" -o "dist/${safe}.test.exe" "$pkg"
+            printf '%s\t%s\n' "${safe}.test.exe" "$rel" >> dist/manifest.tsv
+          done
+          echo "Built lk.exe and:"; cat dist/manifest.tsv
+
+      - name: Upload Windows artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: windows-artifacts
+          path: dist
+          retention-days: 1
+          if-no-files-found: error
+
+  # Run every package's test binary natively, from its package directory so
+  # cwd-relative fixtures resolve. No secrets: TestSessionE2E (in the cmd/lk
+  # binary) skips without LIVEKIT_API_KEY and is exercised by windows-session-e2e
+  # below. node ships on the runner; uv is installed for the Python SDK tests.
+  windows-tests:
+    needs: cross-build
+    runs-on: windows-latest
+    name: Go test on windows-latest
+
+    permissions:
+      contents: read
+
+    steps:
+      - name: Checkout livekit-cli
+        # Test fixtures (cmd/lk/testdata, pkg/agentfs/examples) are read at
+        # runtime; submodules are C source already compiled into the binaries.
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+
+      - name: Download Windows artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: windows-artifacts
+          path: dist
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Run test binaries
+        shell: bash
+        run: |
+          set -uo pipefail
+          root=$(pwd)
+          fail=0
+          while IFS=$'\t' read -r exe rel; do
+            echo "::group::$rel"
+            ( cd "$rel" && "$root/dist/$exe" -test.v -test.count=1 ) || fail=1
+            echo "::endgroup::"
+          done < "$root/dist/manifest.tsv"
+          exit $fail
+
+  # Drive the real session lifecycle on Windows against the prebuilt lk.exe.
+  # Needs live LiveKit credentials, so skip on pull_request (forks can't read
+  # secrets); the cmd/lk test binary already exists from cross-build.
+  windows-session-e2e:
+    needs: cross-build
+    if: github.event_name != 'pull_request'
+    runs-on: windows-latest
+    name: lk agent with ${{ matrix.lang }} agent on windows-latest
+
+    # Same `lang` matrix as session-e2e.yaml's e2e job: Python and Node echo
+    # agents. The cross-built binaries are language-agnostic, so one build
+    # feeds both arms.
+    strategy:
+      fail-fast: false
+      matrix:
+        lang: [python, node]
+
+    permissions:
+      contents: read
+
+    steps:
+      - name: Checkout livekit-cli
+        # Needed for the echo-agent fixtures; submodules are compiled into lk.exe.
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+
+      - name: Download Windows artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: windows-artifacts
+          path: dist
+
+      - name: Set up Python
+        if: matrix.lang == 'python'
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Set up uv
+        if: matrix.lang == 'python'
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Sync echo agent deps
+        if: matrix.lang == 'python'
+        working-directory: cmd/lk/testdata/echo-agent
+        run: uv sync
+
+      - name: Set up Node
+        if: matrix.lang == 'node'
+        uses: actions/setup-node@v4
+        with:
+          # --experimental-strip-types (used to run the .ts entrypoint) needs >= 22.6.
+          node-version: "22"
+
+      - name: Install Node echo agent deps
+        if: matrix.lang == 'node'
+        working-directory: cmd/lk/testdata/echo-agent-node
+        run: npm install
+
+      - name: Run session e2e
+        # Run from cmd/lk so the test's relative testdata/ entrypoint paths
+        # resolve; point it at the cross-built lk.exe so nothing rebuilds.
+        shell: bash
+        working-directory: cmd/lk
+        env:
+          LK_SESSION_E2E_BIN: ../../dist/lk.exe
+          LIVEKIT_API_KEY: ${{ secrets.LIVEKIT_API_KEY }}
+          LIVEKIT_API_SECRET: ${{ secrets.LIVEKIT_API_SECRET }}
+          LIVEKIT_URL: ${{ secrets.LIVEKIT_URL }}
+          # Default (unset) targets the Python fixture; point at the Node one for that arm.
+          LK_SESSION_E2E_AGENT: ${{ matrix.lang == 'node' && 'testdata/echo-agent-node/agent.ts' || '' }}
+        run: |
+          ../../dist/cmd_lk.test.exe \
+            -test.run TestSessionE2E -test.count=1 -test.v -test.timeout 600s